vurakit/agentup/go

Name: go
Author: vurakit

Claude Code and agent skill by vurakit/agentup

Trust tier 3

community

By vurakit
Coding
vurakit/agentup
skills/go/SKILL.md
Updated 18 Sep 2026
Version 1.0.01 version recorded

Source check pending

Checking that the SKILL.md file is still in the repository.

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.

Install

npx vskill@latest install vurakit/agentup/go

SKILL.md

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)

bash

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:

bash

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

bash

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

dockerfile

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

yaml

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

makefile

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

Security

Security scanPassed, 95 of 100Pattern checks on the skill's files.
Model reviewPassed

See the full security report

Quality evaluation

Task evaluationNot runNo evaluation yet. Run one in Skill Studio.

See evaluation results

Source

SKILL.md in the repositoryCheckingskills/go/SKILL.md

Popularity

Repository stars: 56
Repository forks: 15
7-day trend score: 20

Stars and forks are for the whole GitHub repository, not this skill alone. Refreshed 23 Jun 2026, 4 months ago.

Works with

Any agent vskill installs to: 56 targets in all. These 39 have a page on this site.

Claude Code
Cursor
GitHub Copilot
Windsurf
Codex
Gemini CLI
Cline
Amp
Roo Code
Goose
Continue
Kilo Code
Junie
Trae
OpenHands
Qwen Code
AI Agent
Tabnine Chat
Sourcegraph Cody
Amazon Q
Firebase Genkit
Sweep
Devin
Phind
Mentat
Claude Desktop
Aider
GPT Pilot
Plandex
bolt.new
v0
Replit Agent
Anse
TypingMind
BetterChatGPT
LibreChat
Warp AI
Pieces
Fig AI

Embed badge

[![vskill VERIFIED](https://verified-skill.com/api/v1/skills/vurakit/agentup/go/badge)](https://verified-skill.com/skills/vurakit/agentup/go)

Something wrong with this skill or its page? Tell us.