samber/golang-how-to

Orquestrador de habilidades Golang — sempre ativo em qualquer tarefa de codificação, revisão, depuração ou configuração em Go. Lê o contexto da tarefa e carrega as habilidades mais relevantes do samber/cc-skills-golang, muitas vezes várias ao mesmo tempo.

O que é golang-how-to?

O skill **samber/golang-how-to** atua como um orquestrador inteligente de habilidades Go para agentes de IA como Claude Code, Cursor ou Codex. Ele analisa o contexto de qualquer tarefa relacionada a Go — codificação, revisão, depuração ou configuração — e carrega simultaneamente as habilidades primária e secundárias mais relevantes do repositório `samber/cc-skills-golang`. Por exemplo, ao escrever um serviço gRPC, ele carrega `golang-grpc`, `golang-testing` e `golang-error-handling`. Para depurar um panic, carrega `golang-troubleshooting`, `golang-safety` e, se relacionado a desempenho, `golang-benchmark`. Ele também lida com ambiguidades entre habilidades sobrepostas (como desempenho vs. benchmark vs. solução de problemas, ou as bibliotecas `samber/lo` vs. `mo` vs. `ro`) por meio de tabelas de desambiguação. Além disso, pode configurar o arquivo `agent-config` do projeto (como `CLAUDE.md`, `AGENTS.md`, `GEMINI.md`, regras do Cursor ou instruções do Copilot) para forçar o carregamento automático de habilidades, usando o comando `/golang-how-to configure`. O skill depende do `gopls` para navegação de código e funciona com ferramentas LSP nativas ou servidores MCP.

Funciona com✓Claude Code✓Codex CLI✓Cursor✓Gemini CLI
npx skills add https://github.com/samber/cc-skills-golang/tree/main/skills/golang-how-to

Installed? Explore more Programação e Desenvolvimento skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Persona: Você é um orquestrador de habilidades Go. Para cada tarefa Go, identifique todas as habilidades relevantes e carregue-as juntas — uma tarefa raramente pertence a uma única habilidade.

Modos:

  • Orquestrar — para qualquer tarefa de codificação, revisão, depuração ou configuração em Go, carregue a habilidade primária e todas as habilidades secundárias aplicáveis simultaneamente.
  • Desambiguar — quando duas habilidades parecerem sobrepostas, mostre a tabela de limites. Consulte desambiguacao.md.
  • Configurar — escreva a diretiva de carregamento automático para o próprio golang-how-to, mais um bloco opcional ## Habilidades Go Requeridas, no arquivo de configuração do agente do projeto (CLAUDE.md, AGENTS.md ou equivalente). Siga configuracao-projeto.md.

Perguntas: No modo Configurar, faça perguntas ao usuário através da ferramenta de perguntas do ambiente — nunca como texto simples. Uma pergunta por vez, aguarde a resposta. Se o ambiente não tiver ferramenta de perguntas, pergunte em texto simples com as mesmas opções.

Dependências: gopls — go install golang.org/x/tools/gopls@latest; a ferramenta LSP integrada do Claude Code também precisa de ENABLE_LSP_TOOL=1 e um servidor de linguagem Go configurado (consulte Navegação de código com gopls).

Carregamento de habilidades

Para cada tarefa, carregue a habilidade primária e todas as habilidades secundárias aplicáveis ao mesmo tempo. Não espere — carregue-as juntas no início.

IntençãoPrimáriaTambém carregue
Projetar uma API, escolher um padrãogolang-design-patternsgolang-structs-interfaces, golang-naming
Nomear um tipo, função ou pacotegolang-naminggolang-code-style
Lidar com erros de forma idiomáticagolang-error-handlinggolang-safety (código com muitos nil)
Escrever goroutines, canais, sincronizaçãogolang-concurrencygolang-context (se houver cancelamento)
Passar prazos / cancelar operaçõesgolang-contextgolang-concurrency (se houver goroutines)
Projetar structs, embutir, usar interfacesgolang-structs-interfacesgolang-design-patterns
Consultas e transações de banco de dadosgolang-databasegolang-error-handling, golang-security
Construir um serviço gRPCgolang-grpcgolang-testing, golang-error-handling
Construir uma API GraphQLgolang-graphqlgolang-testing, golang-error-handling
Construir uma árvore de comandos CLIgolang-spf13-cobragolang-cli, golang-spf13-viper (se houver config)
Camada de configuração a partir de flags/arquivo/envgolang-spf13-vipergolang-spf13-cobra
Escrever testesgolang-testinggolang-stretchr-testify (se usar testify)
Aplicar padrões de otimizaçãogolang-performancegolang-benchmark (medir primeiro)
Medir com pprof / benchstatgolang-benchmarkgolang-performance (corrigir), golang-troubleshooting (causa raiz)
Depurar um panic ou comportamento inesperadogolang-troubleshootinggolang-safety, golang-benchmark (se relacionado a desempenho)
Monitorar em produçãogolang-observabilitygolang-performance (se violação de SLO)
Auditar vulnerabilidades de segurançagolang-securitygolang-safety, golang-lint
Revisar formatação e estilogolang-code-stylegolang-naming, golang-lint
Refatorar ou reestruturar código existentegolang-refactoringgolang-naming, golang-code-style, golang-project-layout
Configurar golangci-lintgolang-lintgolang-code-style
Escrever godoc / README / CHANGELOGgolang-documentationgolang-naming
Configurar uma nova estrutura de projetogolang-project-layoutgolang-design-patterns, golang-dependency-injection, golang-lint
Configurar pipeline CI/CDgolang-continuous-integrationgolang-lint, golang-security
Escolher uma bibliotecagolang-popular-librarieshabilidade específica da biblioteca relevante
Consultar docs, versões, importadores ou CVEs de um pacotegolang-pkg-go-devgolang-dependency-management
Navegar, diagnosticar ou refatorar código local (definições, referências, renomear)golang-gopls—
Adotar novos recursos da linguagem Gogolang-modernizegolang-lint
Usar samber/lo (helpers de slice/map)golang-samber-logolang-data-structures, golang-performance
Usar samber/oops (erros estruturados)golang-samber-oopsgolang-error-handling
Usar log/sloggolang-samber-sloggolang-observability, golang-error-handling
Usar injeção de dependênciagolang-dependency-injectiongolang-google-wire ou golang-uber-dig ou golang-uber-fx ou golang-samber-do

Todos os identificadores de habilidade acima são formas curtas de samber/cc-skills-golang@<nome>.

Navegação de código com gopls

O gopls fornece inteligência semântica de código para Go — ir para definição, localizar referências, diagnósticos, API de pacotes, busca de símbolos, refatoração. → Consulte a habilidade samber/cc-skills-golang@golang-gopls para as três formas de acessá-lo (seu próprio servidor MCP, a ferramenta nativa LSP e sua CLI), a matriz completa de capacidades e fluxos de trabalho eficientes de leitura/edição.

O gopls raciocina apenas sobre o código que está presente e resolvível na compilação local: seu workspace mais cada dependência exatamente como fixada em go.sum (incluindo diretivas replace). Para qualquer fato que não esteja vinculado à sua compilação local — histórico de versões, licenças, importadores do ecossistema, um pacote que você ainda não adicionou — use golang-pkg-go-dev (godig). Consulte a seção godig vs gopls vs Context7 vs govulncheck abaixo para os limites completos.

godig vs gopls vs Context7 vs govulncheck

Quatro ferramentas podem responder "essa dependência é segura para usar", e elas não se sobrepõem tanto quanto parecem:

  • Context7 é um buscador de documentação de uso geral e multi-linguagem — útil quando não existe uma fonte mais específica. Para um pacote ou módulo Go, o godig é quase sempre a melhor escolha: ele busca dados estruturados e específicos de Go diretamente do pkg.go.dev — versões exatas, símbolos exportados com assinaturas, exemplos executáveis, imported-by e vulnerabilidades conhecidas — ao contrário dos documentos genéricos raspados/curated do Context7, que não expõem essa estrutura e podem ficar desatualizados ou perder módulos Go menos conhecidos. Recorra ao Context7 apenas quando a documentação de uma dependência genuinamente não existir ou não estiver indexada no pkg.go.dev.
  • godig responde perguntas sobre o ecossistema publicado: qualquer pacote ou módulo Go, esteja ou não no seu go.mod — ele chama a API remota do pkg.go.dev e nunca toca no seu checkout local. Seu comando vulns relata CVEs conhecidas para um pacote/versão isoladamente, independentemente de sua compilação realmente atingir o caminho de código vulnerável.
  • gopls (→ samber/cc-skills-golang@golang-gopls, via seu servidor MCP, a ferramenta nativa LSP ou sua CLI) responde perguntas sobre sua compilação específica: seu código mais cada dependência exatamente como fixada em go.sum, com diretivas replace aplicadas. Ele entende quais caminhos de código são realmente alcançáveis e pode responder "esta função vulnerável é realmente chamada no meu código?" — algo que ferramentas que analisam apenas o código-fonte publicado não conseguem.
  • govulncheck é uma ferramenta CLI e biblioteca que mescla as duas abordagens: ela usa o banco de dados de vulnerabilidades Go oficial (como o godig) e, em seguida, aplica análise de fluxo de chamadas entre pacotes (como o gopls) para suprimir falsos positivos — vulnerabilidades em dependências que não são realmente alcançáveis a partir do seu código. No entanto, essas duas etapas são invocadas como uma única execução discreta, e o govulncheck não serve como um servidor LSP contínuo.

Configuração do projeto

Execute /golang-how-to configure para anexar as diretivas de carregamento automático ao arquivo de configuração do agente do projeto (CLAUDE.md, AGENTS.md, GEMINI.md, regras do Cursor ou instruções do Copilot). O comando solicitará:

  1. Caminho do arquivo de configuração (ou confirme o padrão).
  2. Habilidades adicionais para carregar sempre (opcional, separadas por espaço).
  3. Modo de desambiguação (automático ou manual).

Após a configuração, o agente carregará o golang-how-to e qualquer habilidade listada em ## Habilidades Go Requeridas no início de cada conversa.

Depuração

Se o agente não estiver carregando as habilidades esperadas:

  • Verifique se o arquivo de configuração do agente contém a diretiva always_load ou equivalente para golang-how-to.
  • Confirme que o modelo suporta carregamento de habilidades (Claude Code, Cursor, Codex).
  • Execute /golang-how-to configure novamente para reescrever a configuração.
  • Verifique os logs do agente para erros de resolução de habilidades (samber/cc-skills-golang@<nome> deve ser acessível).

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

samber/golang-benchmark

Golang benchmarking, profiling, and performance measurement. Use when writing, running, or comparing Go benchmarks, profiling hot paths with pprof, interpreting CPU/memory/trace profiles, analyzing results with benchstat, setting up CI benchmark regression detection, or investigating production performance with Prometheus runtime metrics. Also use when the developer needs deep analysis on a specific performance indicator - this skill provides the measurement methodology, while `samber/cc-skills-golang@golang-performance` provides the optimization patterns.

samber/golang-cli

Golang CLI application development. Use when building, modifying, or reviewing a Go CLI tool — especially for command structure, flag handling, configuration layering, version embedding, exit codes, I/O patterns, signal handling, shell completion, argument validation, and CLI unit testing. Also triggers when code uses cobra, viper, or urfave/cli. For cobra-specific APIs → See `samber/cc-skills-golang@golang-spf13-cobra` skill; for viper configuration layering → See `samber/cc-skills-golang@golang-spf13-viper` skill.

samber/golang-code-style

Golang code style conventions — line length and breaking, variable declarations, control flow clarity, when comments help vs hurt. Use when writing or reviewing Go code, asking about style or clarity, or establishing project coding standards. Not for naming conventions (→ See `samber/cc-skills-golang@golang-naming` skill), linter configuration (→ See `samber/cc-skills-golang@golang-lint` skill), or doc comments (→ See `samber/cc-skills-golang@golang-documentation` skill).

samber/golang-concurrency

Golang concurrency patterns. Use when writing or reviewing concurrent Go code involving goroutines, channels, select, locks, sync primitives, errgroup, singleflight, worker pools, or fan-out/fan-in pipelines. Also triggers when you detect goroutine leaks, race conditions, channel ownership issues, or need to choose between channels and mutexes.

samber/golang-context

Idiomatic context.Context usage in Golang — propagation through API boundaries, cancellation, timeouts and deadlines, request-scoped values, context.WithoutCancel for background work outliving requests. Apply when designing context propagation across layers, debugging leaked or unexpired contexts, choosing between context.Background/TODO/WithoutCancel, or storing values in context. Not for code that merely accepts ctx as first parameter.

samber/golang-continuous-integration

CI/CD pipeline configuration using GitHub Actions for Golang projects — testing, linting, SAST, security scanning, code coverage, Dependabot, Renovate, GoReleaser, code review automation, and release pipelines. Use when setting up or improving Go project CI, configuring GitHub Actions workflows, adding linters or security scanners, automating dependency updates, or adding quality gates.

samber/golang-database

Comprehensive guide for Go database access — parameterized queries, struct scanning, NULLable columns, transactions, isolation levels, SELECT FOR UPDATE, connection pool, batch processing, context propagation, and migration tooling. Use when writing, reviewing, or debugging Golang code that interacts with PostgreSQL, MariaDB, MySQL, or SQLite; for database testing; or for questions about database/sql, sqlx, or pgx. Does NOT generate database schemas or migration SQL.

samber/golang-data-structures

Golang data structures — slices (internals, capacity growth, preallocation, slices package), maps (internals, hash buckets, maps package), arrays, container/list/heap/ring, strings.Builder vs bytes.Buffer, generic collections, pointers (unsafe.Pointer, weak.Pointer), and copy semantics. Use when choosing or optimizing Go data structures, implementing generic containers, using container/ packages, unsafe or weak pointers, or questioning slice/map internals.

samber/golang-dependency-injection

Comprehensive guide for dependency injection (DI) in Golang. Covers why DI matters (testability, loose coupling, separation of concerns, lifecycle management), manual constructor injection, and DI library comparison (google/wire, uber-go/dig, uber-go/fx, samber/do). Use this skill when designing service architecture, setting up dependency injection, refactoring tightly coupled code, managing singletons or service factories, or when the user asks about inversion of control, service containers, or wiring dependencies in Go. For a specific DI library, → See `samber/cc-skills-golang@golang-google-wire`, `samber/cc-skills-golang@golang-uber-dig`, `samber/cc-skills-golang@golang-uber-fx`, or `samber/cc-skills-golang@golang-samber-do` skills.

samber/golang-dependency-management

Dependency management strategies for Golang projects — go.mod management, installing/upgrading packages, Minimal Version Selection, vulnerability scanning, outdated dependency tracking, binary size analysis, Dependabot/Renovate setup, conflict resolution, and go.work workspaces. Use when adding, removing, or upgrading Go dependencies, auditing vulnerabilities, resolving version conflicts, or setting up automated dependency updates.

samber/golang-design-patterns

Idiomatic Golang design patterns — functional options, constructors, error flow and cascading, resource management and lifecycle, graceful shutdown, resilience, architecture, dependency injection, data handling, streaming, and more. Apply when explicitly choosing between architectural patterns, implementing functional options, designing constructor APIs, setting up graceful shutdown, applying resilience patterns, or asking which idiomatic Go pattern fits a specific problem.

samber/golang-documentation

Comprehensive documentation guide for Golang projects, covering godoc comments, README, CONTRIBUTING, CHANGELOG, Go Playground, Example tests, API docs, and llms.txt. Use when writing or reviewing doc comments, documentation, adding code examples, setting up doc sites, or discussing documentation best practices. Triggers for both libraries and applications/CLIs.

samber/golang-error-handling

Idiomatic Golang error handling — creation, wrapping with %w, errors.Is/As, errors.Join, custom error types, sentinel errors, panic/recover, the single handling rule, structured logging with slog, HTTP request logging middleware, and samber/oops for production errors. Built to make logs usable at scale with log aggregation 3rd-party tools. Apply when creating, wrapping, inspecting, or logging errors in Go code. For samber/oops specifics → See `samber/cc-skills-golang@golang-samber-oops` skill; for slog handler ecosystem → See `samber/cc-skills-golang@golang-samber-slog` skill.

samber/golang-google-wire

Compile-time dependency injection in Golang using google/wire — wire.NewSet, wire.Build, wire.Bind (interface→concrete), wire.Struct, wire.Value, wire.InterfaceValue, wire.FieldsOf, cleanup functions, //go:build wireinject injector files, and generated wire_gen.go. Apply when using or adopting google/wire, when the codebase imports `github.com/google/wire`, or when wiring an application graph at compile time via `wire.Build`. For runtime DI with reflection, see `samber/cc-skills-golang@golang-uber-dig` skill.

samber/golang-gopls

Golang semantic code intelligence via `gopls`, the official Go language server — go-to-definition, find references, call/implementation hierarchy, workspace symbol search, package API discovery, diagnostics, safe rename, refactors (extract/inline/fill/rewrite code actions), formatting, and generated tests. Reaches an agent via gopls's own MCP server (`go_*` tools), Claude Code's native `LSP` tool, or the `gopls` CLI. Use when navigating or refactoring Go code — jumping to a definition, finding call sites before a rename, understanding a file's or package's dependencies, running diagnostics after an edit, or extracting/inlining/renaming. Not for the published ecosystem — packages not in your `go.mod`, versions, licenses, importers — → See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`). Not for a whole-tree vulnerability audit → See `samber/cc-skills-golang@golang-security` skill (`govulncheck`).

samber/golang-graphql

Implements GraphQL APIs in Golang using gqlgen or graphql-go. Apply when building GraphQL servers, designing schemas, writing resolvers, handling subscriptions, or integrating GraphQL with existing Go HTTP services. Also apply when the codebase imports `github.com/99designs/gqlgen` or `github.com/graph-gophers/graphql-go`.

samber/golang-grpc

Provides gRPC usage guidelines, protobuf organization, and production-ready patterns for Golang microservices. Use when implementing, reviewing, or debugging gRPC servers/clients, writing proto files, setting up interceptors, handling gRPC errors with status codes, configuring TLS/mTLS, testing with bufconn, or working with streaming RPCs.

samber/golang-lint

Linting best practices and golangci-lint configuration for Golang projects — running linters, configuring .golangci.yml, suppressing warnings with nolint directives, interpreting lint output, and selecting linters. Use when configuring golangci-lint, asking about lint warnings or nolint suppressions, setting up code quality tooling, or choosing linters. Also use when the user mentions golangci-lint, go vet, staticcheck, or revive.

samber/golang-modernize

Modernize Golang code to use recent language features, standard library improvements, and idiomatic patterns. Trigger proactively when writing or reviewing Go code and old-style patterns are detected, or when encountering a deprecation warning. Also use when the user explicitly asks for modernization, a Go version upgrade, or a CI/tooling refresh.

samber/golang-naming

Go (Golang) naming conventions — covers packages, constructors, structs, interfaces, constants, enums, errors, booleans, receivers, getters/setters, functional options, acronyms, test functions, and subtest names. Use this skill when writing new Go code, reviewing or refactoring, choosing between naming alternatives (New vs NewTypeName, isConnected vs connected, ErrNotFound vs NotFoundError, StatusReady vs StatusUnknown at iota 0), debating Go package names (utils/helpers anti-patterns), or asking about Go naming best practices. Also trigger when the user mentions MixedCaps vs snake_case, ALL_CAPS constants, Get-prefix on getters, or error string casing. Do NOT use for general Go implementation questions that don't involve naming decisions.

Habilidades Relacionadas