docs: fix quickstart instructions to reflect actual workflow

- Explain generated service structure
- Add accurate endpoint definition example
- Show proper .api file editing workflow
- Include logic implementation example
- Remove incorrect curl test before endpoint exists

Signed-off-by: kevin <wanjunfeng@gmail.com>

Author: kevwan

QUICKSTART.md

@@ -20,13 +20,13 @@ mcp-zero is an MCP (Model Context Protocol) server that brings go-zero framework
 
 ```bash
 go install github.com/zeromicro/go-zero/tools/goctl@latest
-```
+```text
 
 Verify installation:
 
 ```bash
 goctl --version
-```
+```text
 
 ### 2. Install mcp-zero
 
@@ -36,13 +36,13 @@ Build from source:
 git clone https://github.com/zeromicro/mcp-zero.git
 cd mcp-zero
 go build -o mcp-zero
-```
+```text
 
 After the project is published, you'll be able to install via:
 
 ```bash
 go install github.com/zeromicro/mcp-zero@latest
-```
+```text
 
 ### 3. Configure Claude Desktop
 
@@ -59,7 +59,7 @@ Add to your Claude Desktop configuration (`~/Library/Application Support/Claude/
     }
   }
 }
-```
+```text
 
 **Note**: Adjust paths to match your installation locations.
 
@@ -73,9 +73,9 @@ Quit and restart Claude Desktop to load the new MCP server.
 
 Open Claude Desktop and try:
 
-```
+```text
 Create a new API service called "userservice" on port 8080
-```
+```text
 
 Claude will use mcp-zero to:
 
@@ -87,7 +87,7 @@ Claude will use mcp-zero to:
 
 Example response:
 
-```
+```text
 Successfully created api service 'userservice'
 
 Output directory: /your/current/directory/userservice
@@ -100,6 +100,49 @@ Next steps:
   1. cd /your/current/directory/userservice
   2. go mod tidy
   3. go run .
+```text
+
+### Understanding the Generated Structure
+
+The generated service includes:
+- `userservice.api` - API specification file
+- `etc/userservice.yaml` - Configuration file
+- `internal/handler/` - HTTP handlers
+- `internal/logic/` - Business logic
+- `internal/svc/servicecontext.go` - Service context
+- `userservice.go` - Main entry point
+
+### Adding Your First Endpoint
+
+Before running the service, you need to define your API endpoints. Edit the `userservice.api` file:
+
+```go
+syntax = "v1"
+
+info (
+    title: "userservice"
+    desc: "userservice API"
+    author: "your name"
+    email: "your@email.com"
+)
+
+type (
+    PingRequest {}
+    PingResponse {
+        Message string `json:"message"`
+    }
+)
+
+service userservice-api {
+    @handler PingHandler
+    get /ping (PingRequest) returns (PingResponse)
+}
+```
+
+Then regenerate the code:
+
+```text
+Generate code from the userservice.api file in ./userservice
 ```
 
 ### Running the Service
@@ -109,37 +152,48 @@ cd userservice
 go run userservice.go
 ```
 
-Test it:
+Now test it:
 
 ```bash
 curl http://localhost:8080/ping
 # Response: {"message":"pong"}
 ```
 
-### Adding an Endpoint
+You'll need to implement the logic in `internal/logic/pinglogic.go`:
 
-To add new endpoints, you'll need to:
+```go
+func (l *PingLogic) Ping(req *types.PingRequest) (resp *types.PingResponse, err error) {
+    return &types.PingResponse{
+        Message: "pong",
+    }, nil
+}
+```
 
-1. Edit the `.api` file manually to add your endpoint
-2. Regenerate code from the updated spec:
+### Adding More Endpoints
 
-```
-Generate code from the userservice.api file in ./userservice
-```
+To add another endpoint, just add it to the `.api` file and regenerate:
 
-Claude will use the `generate_api_from_spec` tool to regenerate the service with your new endpoints.
+```go
+service userservice-api {
+    @handler PingHandler
+    get /ping (PingRequest) returns (PingResponse)
+
+    @handler UserInfoHandler
+    get /user/:id (UserInfoRequest) returns (UserInfoResponse)
+}
+```
 
 ### Creating an RPC Service
 
-```
+```text
 Create an RPC service called "authservice" with methods Login and Verify
-```
+```text
 
 ### Analyzing a Project
 
-```
+```text
 Analyze the project in /path/to/my/go-zero/project
-```
+```text
 
 You'll get:
 
@@ -150,60 +204,60 @@ You'll get:
 
 ### Generating Database Models
 
-```
+```text
 Generate models for the users table in mysql://user:pass@localhost:3306/mydb
-```
+```text
 
 ### Creating Middleware
 
-```
+```text
 Generate authentication middleware for JWT tokens
-```
+```text
 
 ## Common Use Cases
 
 ### 1. Starting a New Microservice Project
 
-```
+```text
 Create these services in ./services directory:
 - API gateway on port 8080
 - User service RPC on port 9001
 - Order service RPC on port 9002
-```
+```text
 
 ### 2. Spec-First Development
 
-```
+```text
 Create an API spec for a user service with these endpoints:
 - POST /login
 - POST /register
 - GET /user/:id
 - PUT /user/:id
-```
+```text
 
 Then generate code:
 
-```
+```text
 Generate code from userservice.api
-```
+```text
 
 ### 3. Adding Features to Existing Service
 
-```
+```text
 I have a service at ./userservice. Add rate limiting middleware.
-```
+```text
 
 ### 4. Configuration Management
 
-```
+```text
 Generate a production configuration template for my API service
-```
+```text
 
 ### 5. Migration from Another Framework
 
-```
+```text
 How do I migrate my Express.js API to go-zero?
-```
+```text
 
 ## Tips & Best Practices
 
@@ -222,45 +276,45 @@ How do I migrate my Express.js API to go-zero?
 
 For monorepo:
 
-```
+```text
 myproject/
 ├── services/
 │   ├── api-gateway/
 │   ├── user-service/
 │   └── order-service/
 └── shared/
     └── types/
-```
+```text
 
 Ask Claude:
 
-```
+```text
 Create services in ./services directory
-```
+```text
 
 ### Error Recovery
 
 If generation fails:
 
-```
+```text
 The service generation failed. Try again with corrected parameters.
-```
+```text
 
 mcp-zero preserves partial state, so you won't lose progress.
 
 ### Getting Help
 
-```
+```text
 Explain go-zero middleware
-```
+```text
 
-```
+```text
 What's the difference between API and RPC services in go-zero?
-```
+```text
 
-```
+```text
 Show me best practices for error handling in go-zero
-```
+```text
 
 ## Troubleshooting
 
@@ -308,29 +362,29 @@ Show me best practices for error handling in go-zero
 
 ### Custom Templates
 
-```
+```text
 Use this middleware template for my service:
 [paste your template]
-```
+```text
 
 ### Batch Operations
 
-```
+```text
 Create 5 microservices: user, order, product, payment, notification
 All RPC services, ports starting from 9001
-```
+```text
 
 ### Configuration Validation
 
-```
+```text
 Validate my configuration file at ./etc/config.yaml
-```
+```text
 
 ### Project Documentation
 
-```
+```text
 Generate documentation for my project structure
-```
+```text
 
 ## Environment Variables