Go coding standards and style conventions grounded in Effective Go, Go Code Review Comments, and production-proven idioms. Use when writing or reviewing Go code, enforcing naming conventions, import ordering, variable declarations, struct initialization, or formatting rules. Trigger examples: "check Go style", "fix formatting", "review naming", "Go conventions". Do NOT use for architecture decisions, concurrency patterns, or performance tuning — use go-architecture-review, go-concurrency-review, or go-performance-review instead.
Correct usage of context.Context in Go: propagation, cancellation, timeouts, deadlines, values, and common anti-patterns. Use when: "context usage", "context.Context", "context cancellation", "timeout", "context.WithTimeout", "context.WithCancel", "context values", "context propagation". Do NOT use for: concurrency patterns beyond context (use go-concurrency-review), HTTP middleware context (use go-api-design), or error handling (use go-error-handling).
Correct use of Go's built-in data structures: slices (nil vs empty, append semantics, aliasing, preallocation), maps (comma-ok, sets, iteration order), arrays, and choosing between them. Use when: "slice vs array", "nil slice", "empty slice", "preallocate", "map iteration", "use a set in Go", "slice aliasing", "append gotcha", "copy a slice", "sync.Map or mutex". Do NOT use for: protecting structures shared across goroutines (use go-concurrency-review), allocation profiling (use go-performance-review), or generic container design (use go-design-patterns).
Go documentation conventions: godoc comments, package docs, testable Example functions, deprecation notices, and doc links. Use when: "add godoc", "document this package", "write doc comments", "add examples to docs", "deprecate a function", "package documentation", "improve the docs". Do NOT use for: commit messages (use git-commit), README-level project guides (plain writing task), or code style rules (use go-coding-standards).
Go error handling patterns, wrapping, sentinel errors, custom error types, and the errors package. Grounded in Effective Go, Go Code Review Comments, and production-proven idioms. Use when implementing error handling, designing error types, debugging error chains, or reviewing error handling patterns. Trigger examples: "handle errors", "error wrapping", "custom error type", "sentinel errors", "errors.Is", "errors.As". Do NOT use for panic/recover patterns in middleware (use go-api-design) or test assertion errors (use go-test-quality).
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimnpx claudepluginhub eduardo-sl/go-agent-skillsBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
Curated AI agent skills for Go projects. Install with one command, works everywhere.
npx skills add eduardo-sl/go-agent-skills
Supports Claude Code, Cursor, Codex, GitHub Copilot, Windsurf, OpenCode, and 37+ more agents. Compatible with the open Agent Skills ecosystem and npx skills CLI.
Built on the Uber Go Style Guide, Effective Go, and hard-won production experience with large-scale Go services.
AI coding agents are as good as the context you give them. Without Go-specific guidance, they'll write Java-flavored Go, ignore idiomatic error handling, create goroutine leaks, and use interface{} where generics belong.
These skills teach your agent how to write Go the way experienced Go engineers do — with proper error wrapping, consumer-side interfaces, table-driven tests, and all the idioms that make Go code maintainable at scale.
Skills load automatically based on context. You can also invoke them directly via slash command (e.g., /go-code-review).
| Skill | What it does | Triggers |
|---|---|---|
| go-coding-standards | Style conventions, naming, imports, struct init, formatting | "check Go style", "fix formatting" |
| go-code-review | Structured review process with severity classification | "review this code", "check this PR" |
| go-error-handling | Error wrapping, sentinels, custom types, errors.Is/As | "handle errors", "error wrapping" |
| go-context | Context propagation, cancellation, timeouts, values | "context usage", "timeout", "context cancellation" |
| go-modernize | Generics, slog, errors.Join, slices/maps, range-over-func | "modernize", "use generics", "update Go" |
| go-data-structures | Slices, maps, sets, aliasing, preallocation, nil vs empty | "nil slice", "map iteration", "slice aliasing" |
| go-documentation | Godoc conventions, testable examples, deprecation notices | "add godoc", "document this package" |
| Skill | What it does | Triggers |
|---|---|---|
| go-architecture-review | Package layout, dependency direction, layering, internal/ | "review architecture", "project layout" |
| go-project-layout | Scaffolding new projects: cmd/internal, module naming, thin main | "new Go project", "scaffold a service" |
| go-interface-design | Consumer-side interfaces, composition, compliance checks | "design interface", "accept interfaces" |
| go-api-design | REST/gRPC handlers, middleware, graceful shutdown, pagination | "design API", "HTTP handler" |
| go-grpc | Proto design, status codes, interceptors, deadlines, streaming | "gRPC service", "interceptor", "proto design" |
| go-design-patterns | Functional options, factory, strategy, middleware/decorator | "design pattern", "functional options" |
| go-dependency-injection | Constructor injection, composition root, wire/fx trade-offs | "dependency injection", "remove global state" |
| go-cli | Flags, subcommands, exit codes, signals, Cobra decision point | "build a CLI", "handle Ctrl+C", "exit codes" |
| Skill | What it does | Triggers |
|---|---|---|
| go-database | Connection pools, transactions, sqlc, migrations, repository pattern | "database access", "SQL query", "transactions" |
20 modular skills for idiomatic Go — each under 225 lines, backed by 48 reference files, 8 automation scripts (all with --json, --limit, --force), and 4 asset templates. Covers error handling, naming, testing, concurrency, interfaces, generics, documentation, logging, performance, and more. Activates automatically with progressive disclosure and conditional cross-references.
AI Agent Skills for production-ready Go projects
Go code review and development skills covering architecture, middleware, data persistence, concurrency, and framework-specific patterns for BubbleTea, Wish SSH, and Prometheus.
Go-specific development tools with idiomatic best practices
gopilot is your Go copilot - a skill for writing idiomatic Go code, covering design patterns, error handling, testing, concurrency, generics, and stdlib patterns up to Go 1.26.
Go programming language toolkit for concurrency patterns, error handling, and idiomatic Go practices. Includes Go expert agent for strategic Go architecture decisions.