Go Pro Max

Go Pro Max - Backend Generator

When User Requests Go Work

Follow this workflow for every Go-related task:

1. Analyze Requirements

Extract from the user's request:

• Project type: REST API, CLI, microservice, library, serverless
• Domain: web, database, gRPC, messaging
• Constraints: stdlib only? specific framework? Kubernetes?
• Scale: small project, enterprise, library

Default Stack (always use unless user specifies otherwise)

Project structure: Domain-driven layout:

Copy code
cmd/api/main.go
internal/config/       — env config
internal/domain/       — structs + request types
internal/handler/      — HTTP handlers (Chi)
internal/service/      — business logic
internal/repository/   — PostgreSQL queries
internal/middleware/    — auth, cors, logger
migrations/            — SQL migration files

2. Generate Architecture System (REQUIRED for new projects)

bashCopy code
python3 skills/go/scripts/search.py "<project description>" --arch-system -p "ProjectName"

This gives you: architecture, packages, error strategy, patterns, structure, testing approach.

3. Supplement with Domain Searches

Based on the project needs, search relevant domains:

bashCopy code
# Patterns for the task
python3 skills/go/scripts/search.py "functional options config" --domain pattern

# Error handling approach
python3 skills/go/scripts/search.py "error wrapping context" --domain error

# Concurrency patterns
python3 skills/go/scripts/search.py "worker pool bounded" --domain concurrency

# Performance tips
python3 skills/go/scripts/search.py "http connection pooling" --domain perf

# Testing patterns
python3 skills/go/scripts/search.py "table driven httptest" --domain test

4. Stack Guidelines

If using a specific framework/stack:

bashCopy code
python3 skills/go/scripts/search.py "middleware authentication" --stack web-gin
python3 skills/go/scripts/search.py "cobra subcommands config" --stack cli
python3 skills/go/scripts/search.py "interceptor logging" --stack grpc

5. Implement

Apply all recommendations from the search results:

• Use recommended architecture and project structure
• Apply patterns (Functional Options, Repository Interface, etc.)
• Follow error handling strategy
• Implement proper concurrency patterns
• Add tests following testing strategy

6. Always Generate Docker Files

Every project MUST include these files:

Dockerfile (multi-stage build):

dockerfileCopy code
FROM golang:1.22-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o /bin/api ./cmd/api

FROM alpine:3.20
RUN apk add --no-cache ca-certificates tzdata
COPY --from=builder /bin/api /bin/api
COPY migrations/ /app/migrations/
EXPOSE 8080
CMD ["/bin/api"]

docker-compose.yml (API + PostgreSQL):

yamlCopy code
services:
  api:
    build: .
    ports:
      - "8080:8080"
    environment:
      - DATABASE_URL=postgres://postgres:postgres@db:5432/appdb?sslmode=disable
      - JWT_SECRET=change-me
      - PORT=8080
    depends_on:
      db:
        condition: service_healthy
  db:
    image: postgres:16-alpine
    ports:
      - "5432:5432"
    environment:
      POSTGRES_DB: appdb
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
    volumes:
      - pgdata:/var/lib/postgresql/data
      - ./migrations:/docker-entrypoint-initdb.d
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5
volumes:
  pgdata:

Makefile (must include):

makefileCopy code
dev:
	go run ./cmd/api
build:
	go build -o bin/api ./cmd/api
test:
	go test -race -cover ./...
docker-up:
	docker-compose up -d --build
docker-down:
	docker-compose down

Pre-Delivery Checklist

Before delivering Go code, verify:

• go vet ./... passes
• golangci-lint run passes
• go test -race ./... passes
• No goroutine leaks (all goroutines have shutdown path)
• All errors handled (no _ = f())
• Context propagated through all layers
• http.Response.Body closed with defer
• Exported types have doc comments
• No global mutable state
• Interfaces defined at consumer, not provider
• Struct fields ordered for alignment (largest to smallest)
• strings.Builder used instead of + concatenation in loops
• Database connections properly pooled and closed
• Graceful shutdown implemented for servers

Quick Domain Reference

Resources

• scripts/: BM25 search engine, architecture system generator
• data/: 12 domains and 10 stacks with 300+ curated Go entries