---

name: go-pro-max description: "Go development intelligence. 12 domains, 10 stacks, 300+ entries. Actions: plan, build, create, design, implement, review, fix, improve, optimize, enhance, refactor, check Go code. Domains: pattern, package, error, perf, test, concurrency, interface, arch, idiom, anti, tooling, module. Stacks: web-gin, web-echo, web-fiber, web-stdlib, cli, grpc, database, microservice, cloud-native, data-pipeline. Integrations: arch_system generator."

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)

| Component | Default | Package | |-----------|---------|---------| | Database | PostgreSQL | github.com/lib/pq | | Router | Chi v5 | github.com/go-chi/chi/v5 | | Auth | JWT | github.com/golang-jwt/jwt/v5 | | Query | database/sql | stdlib | | Migration | Raw SQL files | migrations/*.sql | | Config | ENV vars | os.LookupEnv | | Deploy | Docker Compose | Dockerfile + docker-compose.yml |

Project structure: Domain-driven layout:

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)

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:

# 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:

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):

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):

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):

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

| Domain | When to Search | |--------|---------------| | pattern | Need a design pattern (options, factory, middleware, pipeline) | | package | Choosing a library/package for a use case | | error | Error handling strategy, wrapping, custom errors | | perf | Performance optimization, profiling, allocation | | test | Testing approach, mocking, benchmarks | | concurrency | Goroutines, channels, sync primitives | | interface | Interface design, composition, contracts | | arch | Project structure, architecture decisions | | idiom | Go conventions, naming, style | | anti | Avoiding common mistakes | | tooling | Go tools, linting, profiling | | module | Go modules, versioning, dependencies |

Resources

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