Go is the language of choice for high-concurrency systems, but even seasoned Gophers waste hours on boilerplate: context propagation, error wrapping, channel patterns. What if you could skip the typing and jump straight to the architecture? This collection of 12 battle-tested prompts does exactly that. Each prompt is crafted to produce idiomatic, production-ready Go code, from microservice scaffolding to pprof-guided optimization. No fluff, just paste, run, and refactor. Let's turn your AI assistant into a senior Go engineer.
Why Go Prompts Are Different
Go's simplicity is a double-edged sword. The language has few constructs, but the ecosystem is vast: net/http, sync, context, database/sql, testing, pprof. A generic prompt like "write a REST API" yields generic code. But a prompt that specifies httptest, errgroup, and sqlmock produces code that follows Go idioms and passes go vet on the first try. The key is to embed the standard library's best practices into the prompt itself.
1. Microservice Scaffold with Graceful Shutdown
Use case: Generate a complete HTTP microservice skeleton with health checks, graceful shutdown, and structured logging.
Prompt:
Generate a Go microservice using net/http that:
- Exposes /health and /ready endpoints
- Uses context.WithTimeout for graceful shutdown (max 10 seconds)
- Logs requests in JSON format with method, path, duration, and status
- Includes a main.go, handler.go, and server.go
- Uses only the standard library (no third-party deps)
- Compiles with go build ./...
Example output (excerpt):
func main() {
srv := &http.Server{Addr: ":8080", Handler: routes()}
go func() {
log.Fatal(srv.ListenAndServe())
}()
// Graceful shutdown
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
defer stop()
<-ctx.Done()
shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
srv.Shutdown(shutdownCtx)
}
Why it works: The prompt constrains the output to standard library, ensuring no dependency bloat. Graceful shutdown is a non-negotiable production pattern.
2. Context Propagation and Cancellation
Use case: Teach the AI to handle context cancellation in a chain of function calls, a common pitfall in Go.
Prompt:
Write a Go function fetchUser(ctx context.Context, id int) (*User, error) that:
- Calls an external API via http.NewRequestWithContext
- Respects a 3-second timeout
- Returns a wrapped error if the context is canceled
- Uses errors.Is to check for context.Canceled
- Includes a unit test that simulates cancellation
Why it matters: Context cancellation is the backbone of Go's concurrency. A prompt that demands errors.Is ensures the code doesn't lose the cancellation signal.
3. Goroutine Pool with Error Handling
Use case: Process a batch of tasks concurrently without overwhelming the system, and collect errors.
Prompt:
Create a Go function processBatch(items []Item) error that:
- Processes items concurrently with a worker pool of 5 goroutines
- Uses sync.WaitGroup and a buffered channel for jobs
- Collects errors in a slice with mutex protection
- Returns a single error using errors.Join if any jobs fail
- Handles panics in goroutines with recover
Example usage:
items := fetchItemsFromDB() // 1000 items
if err := processBatch(items); err != nil {
log.Printf("batch failed: %v", err)
}
Why it's production-grade: Worker pools prevent unbounded goroutine creation. errors.Join (Go 1.20+) aggregates errors cleanly.
4. SQL with sqlmock for Unit Testing
Use case: Generate database code that is testable without a real database, a crucial skill for highload systems.
Prompt:
Write a Go function GetUserByID(ctx context.Context, id int) (*User, error) using database/sql that:
- Uses a prepared statement
- Handles sql.ErrNoRows by returning a custom ErrNotFound
- Returns a user struct with fields ID, Name, Email
- Provide a unit test using data-dog/go-sqlmock to verify the query and error handling
Why it works: sqlmock allows you to test SQL logic without spinning up Postgres, making tests fast and reliable.
5. JSON API with Validation and Middleware
Use case: Build a REST endpoint with request validation, panic recovery, and request ID propagation.
Prompt:
Generate a Go HTTP handler for POST /api/users that:
- Decodes JSON body into a User struct
- Validates required fields (Name, Email) and returns 400 with a JSON error if invalid
- Uses a middleware chain: recover from panics, add request ID to context, log request
- Returns 201 with the created user as JSON
- Uses only net/http and encoding/json
Example code:
type User struct {
Name string `json:"name"`
Email string `json:"email"`
}
func createUser(w http.ResponseWriter, r *http.Request) {
var u User
if err := json.NewDecoder(r.Body).Decode(&u); err != nil {
http.Error(w, `{"error":"invalid body"}`, http.StatusBadRequest)
return
}
if u.Name == "" || u.Email == "" {
http.Error(w, `{"error":"name and email are required"}`, http.StatusBadRequest)
return
}
// ...
}
6. High-Performance String Concatenation
Use case: Optimize code that builds large strings (e.g., CSV export, log aggregation) by using strings.Builder.
Prompt:
Write a Go function buildCSV(rows [][]string) (string, error) that:
- Uses strings.Builder with Grow() to preallocate capacity
- Escapes commas and quotes in fields
- Returns an error if a field contains a newline
- Include a benchmark comparing it to using + concatenation
Why it matters: strings.Builder is the recommended way to concatenate strings in Go. Preallocating with Grow reduces allocations by up to 90% (as per official Go blog).
7. Context-Aware HTTP Client with Retry
Use case: Create a resilient HTTP client that retries on transient failures, essential for microservices.
Prompt:
Implement a Go function fetchWithRetry(ctx context.Context, url string) ([]byte, error) that:
- Uses http.Client with a 5-second timeout
- Retries up to 3 times on 5xx or network errors
- Uses exponential backoff with jitter (e.g., 100ms, 400ms, 900ms)
- Returns a wrapped error after exhausting retries
- Respects context cancellation during backoff
Example code:
for attempt := 0; attempt < 3; attempt++ {
resp, err := client.Do(req)
if err == nil && resp.StatusCode < 500 {
return readBody(resp)
}
select {
case <-time.After(backoff(attempt)):
case <-ctx.Done():
return nil, ctx.Err()
}
}
8. Profiling with pprof: Find Bottlenecks
Use case: Generate CPU and memory profiles to identify performance issues in a Go service.
Prompt:
Write a Go program that:
- Starts a net/http server on :8080
- Registers /debug/pprof/ handlers
- Runs a CPU-intensive function (e.g., Fibonacci recursive) for 10 seconds
- Generates a CPU profile to cpu.prof and a heap profile to mem.prof
- Prints instructions on how to analyze profiles with go tool pprof
Usage:
go run main.go
curl http://localhost:8080/debug/pprof/profile?seconds=10 > cpu.prof
go tool pprof -top cpu.prof
Why it's essential: Profiling is the only way to know where your highload service actually spends time. The standard library's net/http/pprof is a goldmine.
9. Error Wrapping with Contextual Info
Use case: Propagate errors with additional context while preserving the original error chain.
Prompt:
Write a Go function that:
- Defines a custom error type with HTTP status and user message
- Uses fmt.Errorf with %w to wrap errors
- Provides a helper to unwrap and extract the status
- Include a test that checks errors.As and errors.Is behavior
Example:
type APIError struct {
Status int
Msg string
Err error
}
func (e *APIError) Error() string { return e.Msg }
func (e *APIError) Unwrap() error { return e.Err }
10. Channels vs. Mutex: When to Use What
Use case: Get AI to explain and generate code for both patterns, then compare.
Prompt:
Compare implementation of a counter that is incremented by 1000 goroutines using:
1) sync.Mutex
2) atomic.AddInt64
3) buffered channel
Provide code for each, run them with go run -race, and explain the performance trade-offs. Add a benchmark to compare speed.
Why it's valuable: This prompt forces the AI to reason about concurrency primitives, not just paste code. The -race flag is a must for any concurrent Go code.
11. Testing with Table-Driven Tests
Use case: Generate thorough unit tests for a function with multiple edge cases.
Prompt:
Write table-driven tests for a function ParseDuration(s string) (time.Duration, error) that:
- Covers valid inputs like "1h30m", "300ms", "1.5h"
- Covers invalid inputs like "", "abc", "1d"
- Uses t.Run for sub-tests
- Checks expected errors with errors.Is
- Include a benchmark for the function
Example structure:
func TestParseDuration(t *testing.T) {
tests := []struct {
name string
in string
want time.Duration
err bool
}{
{"valid", "1h", time.Hour, false},
{"invalid", "1d", 0, true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := ParseDuration(tt.in)
if (err != nil) != tt.err { t.Errorf(...) }
if got != tt.want { t.Errorf(...) }
})
}
}
12. Code Review: Find and Fix Issues
Use case: Use AI as a reviewer to detect common Go pitfalls.
Prompt:
Review this Go code for production readiness. Look for:
- Goroutine leaks
- Missing error handling
- Race conditions
- Inefficient memory usage
- Incorrect context usage
Provide a list of issues with severity and fix suggestions.
Why it's powerful: This prompt turns the AI into a linter that understands semantics, not just syntax.
Conclusion
These 12 prompts cover the daily grind of a Go developer: from scaffolding to profiling. The secret is in the specificity — each prompt embeds constraints that force idiomatic, production-grade output. Start with the scaffold prompt, then layer in context, testing, and optimization. Your code will be cleaner, your tests more thorough, and your highload services more robust. Paste these into your favorite AI tool, adapt them to your project, and watch your productivity soar.
Comments