samber/cc-skills-golang
41 skills140k installs82.9k starsGitHub
Install
npx skills add https://github.com/samber/cc-skills-golangSkills in this repo
1Golang Error Handlinggolang-error-handling is an agent skill package that encodes production-grade Go error and logging habits for solo builders shipping APIs, CLIs, and backend services. It is aimed at developers who want their agent to match team-style standards without re-explaining conventions every session. Use it when generating or refactoring handlers, middleware, and batch jobs where slog, structured context, and clear operator messages matter. The skill is backed by named eval scenarios such as middleware log chains and order processors, so assertions steer the model away from high-cardinality strings and one-shot error returns. It does not replace a full linter suite, but it tightens the default output during the build phase so review and ship steps see fewer logging and wrapping anti-patterns. Pair it with your normal test and review workflow after the agent drafts code.4.3kinstalls2Golang Performancegolang-performance is an agent skill for indie builders running Go HTTP APIs and workers who need disciplined speedups under real load. It combines a profiling-first mindset—do not rewrite hot paths until you know whether CPU, allocations, GC, or blocking I/O dominates—with ready-to-adapt Prometheus alert snippets for GC pause time, runaway goroutines, and memory trending toward container limits. The embedded eval stresses that agents should recommend measurement (profiles, rates, baselines) before suggesting code edits on a seemingly slow handler. Use it while you are still building performance-sensitive backend code, when you are shipping and hardening SLOs, and when you are operating services that already export Go runtime metrics. It fits Claude Code or Cursor sessions on monolithic APIs, microservices, and CLI tools where a few allocation or concurrency mistakes become production incidents.4.3kinstalls3Golang Design Patternsgolang-design-patterns is an agent skill for solo builders writing Go services, CLIs, and APIs who want constructor and lifecycle APIs that match common production style instead of patterns transplanted from Java or C#. It focuses on idiomatic choices such as functional options for optional configuration, defaults applied inside New-style constructors, and returning errors from options when validation matters. It also pushes explicit initialization over init() for database clients and other resources so packages stay testable and dependencies stay visible. Use it when an agent is drafting HTTP servers, repositories, or libraries whose configuration will grow over time and you want consistent naming, extensibility, and reviewable structure before you merge. It is not a linter replacement; it shapes how the agent designs types and APIs the first time.4.1kinstalls4Golang TestingGolang-testing is a Go-focused agent skill that treats tests as executable specifications rather than coverage theater. Solo builders and small teams use it when adding tests to a module, reviewing existing `_test.go` files, choosing between table-driven layouts and testify suites, or hardening CI with golangci-lint and gotests-assisted scaffolding. It covers production patterns: parallel subtests, fuzzing, fixture hygiene, snapshot comparisons, integration boundaries, and leak detection. The skill explicitly defers testify API details and benchmark methodology to sibling skills in the same repo. Invoke it during active implementation when behavior must be locked down, again before release when flakiness appears, and whenever an agent needs a consistent review pass over Go test quality.4kinstalls5Golang Code Stylegolang-code-style is an agent skill package that encodes opinionated Go initialization and naming habits through scored coding exercises rather than a loose style guide. Solo and indie builders shipping APIs, CLIs, or internal services use it when they want Claude Code, Cursor, or Codex to write Go that reads like experienced backend code—where `var` announces “start at the zero value on purpose” and `:=` is reserved for meaningful non-zero setup such as `time.Now()` or populated slices. Each prompt pairs a realistic file task with a deliberate trap (for example, stuffing `requestCount := 0` into a constructor) and machine-checkable assertions, which makes the skill closer to a linter-backed tutor than generic “write clean Go” advice. Install it during active backend work or when refactoring packages whose constructors blur intent. It does not replace `gofmt`, static analysis, or team-specific linters, but it sharply reduces agents obscuring business defaults with redundant literals.4kinstalls6Golang Securitygolang-security is an agent skill for solo and indie builders shipping Go backends who want security baked into generated code, not bolted on after a failed review. It encodes Go-specific application security expectations around session stores, password hashing, and similar high-risk patterns that show up in real handlers and login flows. The packaged evals model common agent mistakes—such as accepting a literal session secret from the prompt, using a single cookie-store key instead of separate auth and encryption material, or ignoring bcrypt length limits—so the skill pushes toward environment-backed secrets and correctly configured cookie options. Use it while you are still writing or refactoring auth-related Go code in the Build phase, and again in Ship when you are hardening handlers before production. It is procedural knowledge for Claude Code, Cursor, Codex, and similar agents, not a hosted scanner; pair it with your usual CI and dependency audits on the skill’s Security Audits panel.4kinstalls7Golang Concurrencygolang-concurrency is an agent skill from samber/cc-skills-golang that encodes operational rules for correct Go concurrency when your coding agent writes or refactors goroutines, channels, and timeouts. Solo and indie builders shipping APIs, CLIs, or background workers install it so generated select loops do not allocate a new timer every iteration, and channel ownership stays with the sender to avoid races and panics. The bundled eval readme targets two high-impact mistakes: time.After churn inside loops, and receivers closing channels they do not own. It is meant for hands-on implementation and quick review passes during backend work, not for choosing product ideas or marketing. Pair it with your normal Go toolchain and tests; the skill steers agent output toward patterns that match experienced Go review feedback.4kinstalls8Golang Naminggolang-naming is a Go discipline skill from the cc-skills-golang set that steers agents toward readable, idiomatic package APIs solo builders expect in production services. It encodes concrete expectations through eval-style scenarios such as an apiclient REST package: one primary exported type, functional options, sentinel errors, a status-wrapping error type, and methods like fetch-by-ID. The documented traps target common model mistakes—naming constructors NewClient() instead of New(), bare error strings without a package prefix, and connected bool instead of isConnected. Use it while implementing new Go modules, during ship-phase review before merge, or when refactoring public packages so call sites read apiclient.New() without redundant stutter. It complements generic linters by teaching procedural naming law your agent applies on the next file write, not only on CI failure. Confidence is moderate where the ingested payload is eval JSON rather than a full end-user SKILL.md narrative.3.9kinstalls9Golang ContextGolang Context is an agent skill grounded in eval scenarios that teach correct context.Context usage in Go backend code. Solo builders shipping APIs with database/sql and net/http get nudges to thread request context through queries and external HTTP calls, avoid background contexts in handlers, and pair WithTimeout with deferred cancel. The bundled readme reads like a skill-creator-style benchmark: concrete prompts, known traps, and numbered assertions agents should satisfy. Use it when you or your agent implement handlers, middleware, or retry loops where cancellation and timeouts matter for reliability and resource usage. It complements general Go style guides by focusing on one high-impact failure mode indie services hit under load or flaky networks.3.9kinstalls10Golang Data Structuresgolang-data-structures is a Go-focused agent skill for solo builders shipping APIs, CLIs, and workers who need authoritative guidance on built-in and stdlib structures—not generic CS trivia. It walks slice and map internals, growth and bucket behavior, when to preallocate, arrays versus slices, strings.Builder versus bytes.Buffer, container/list heap and ring, generic collection patterns, and pointer semantics including unsafe and weak pointers, with copy semantics called out explicitly. The persona steers you toward the right structure for access patterns and allocation cost. It defers foot-guns to the sibling golang-safety skill and concurrency primitives to golang-concurrency, so you invoke this skill when designing hot paths, refactoring storage layers, or reviewing a teammate’s map-heavy code. Requires a Go toolchain in the environment; pairs naturally with golangci-lint in allowed tooling for follow-up static checks.3.8kinstalls11Golang Safetygolang-safety is a defensive Go coding skill for Claude Code and similar agents working in repositories that already use Go. It separates everyday correctness from adversarial security: you invoke it when code panics on nil, silently corrupts data through shared slice backing, races on maps, mis-handles numeric conversions, or asks how zero values should behave at API boundaries. The agent adopts a defensive engineer stance and applies a concise best-practices stack—prefer generics over any when types are known, always comma-ok type assertions, careful float compares, explicit copying when mutability crosses ownership lines, and loop-safe defer patterns. It fits solo builders shipping APIs, CLIs, or small SaaS backends who cannot afford production panics from one untested assumption. Use during active backend work, pre-merge review, or when debugging a stack trace that smells like nil or aliasing. Pair with your normal linter workflow; the skill expects go and optional golangci-lint on the machine.3.8kinstalls12Golang Documentationgolang-documentation is a Documentation-category agent skill for Go maintainers—especially solo developers who must sound like a technical writer while shipping libraries, services, or CLIs alone. It defines a technical-writer persona and two modes: Write mode to generate missing layers from a structured checklist, and Review mode to audit completeness, accuracy, and style with parallel sub-agents split across doc comments, README, CONTRIBUTING, CHANGELOG, and library-specific surfaces. Triggers include writing or reviewing godoc, adding runnable examples, standing up doc sites, or debating documentation best practices. The skill treats docs as a first-class deliverable for readers who have never opened the repo, including llms.txt for agent discoverability—a growing need for indie OSS and internal tools. Pair it during Build when packages stabilize, and again in Ship when you need a pre-release documentation pass without hiring a writer.3.8kinstalls13Golang DatabaseGolang Database is a comprehensive agent skill for Go engineers who treat SQL as first-class: parameterized queries, scanning into structs, NULL handling, transactions with explicit isolation, row locking, connection pools, batch operations, context deadlines, and migration tooling awareness. It targets PostgreSQL, MariaDB, MySQL, and SQLite via database/sql, sqlx, or pgx—not ORMs. Solo builders shipping APIs or worker services invoke it when writing new repository functions, reviewing PRs for injection or N+1 issues, or debugging subtle transaction bugs. Write mode follows sequential instructions and suggests grepping the codebase for naming conventions first; review mode acts as an auditor at the data boundary. The skill requires Go installed and fits Claude Code-style agents with bash for go and golangci-lint. It does not author DDL or migration files, keeping scope on safe, observable application database code.3.8kinstalls14Golang Modernizegolang-modernize is an agent skill for solo and indie builders maintaining Go codebases who want current language features, standard library calls, and idiomatic patterns without manual migration research. Invoke it proactively while writing or reviewing Go when you spot legacy patterns, see compiler or linter deprecation notices, or when you ask for a Go version bump or CI refresh. Inline mode keeps suggestions scoped to what you are editing and only flags other hotspots in passing; full-scan mode suits an explicit modernization pass or pipeline job and can parallelize scans for deprecated packages versus API replacements. The skill behaves like a pragmatic modernization engineer: fix what breaks or will break soon, then improve clarity, then optional polish. It fits Claude Code-style agents with shell access to go and golangci-lint on real repos, not greenfield tutorials.3.8kinstalls15Golang Popular LibrariesGolang Popular Libraries is a Go-focused agent skill that teaches solo builders to default to the standard library and add popular third-party packages only when evidence demands it. The documented pattern centers on JSON handling for high-throughput APIs: colleagues may urge jsoniter or sonic upfront, but the skill instructs agents to recommend encoding/json first, profile with pprof, and treat dependency adds as a measured response to confirmed bottlenecks—not folklore about slowness. It fits indie API and CLI backends where every dependency is maintenance debt. Install it when scaffolding services, reviewing dependency choices, or when chat models reflexively suggest trendy libraries without measurement. Outputs are reasoned library recommendations aligned with cc-skills-golang assertion checks, making it especially useful inside Cursor or Claude Code Go workflows where agents otherwise over-fit to Reddit-speed myths.3.8kinstalls16Golang Project Layoutgolang-project-layout is a Go-oriented agent skill that encodes conventional repo hygiene for solo builders shipping binaries and HTTP services. Rather than debating folder structure ad hoc, it aligns artifacts with familiar patterns: application entry under `cmd/` (including `cmd/server` and `build-all` for every command package), a Makefile that wires verbose builds, race-enabled tests, coverage HTML, and short test runs, plus gitignore coverage for dist output, vendor trees, IDE noise, and local secrets files. Environment and tooling touches include optional Air hot-reload directories and parameterized `BINARY_NAME`, `GO`, and `GOFLAGS`. Invoke it when spinning up a new Go microservice or CLI so your agent does not omit lint, benchmark, or watch targets you will want on day two. It is scaffolding and convention—not a substitute for domain API design—but it compresses setup time for indie backends you plan to ship and operate yourself.3.7kinstalls17Golang Troubleshootinggolang-troubleshooting is a Go-focused debugging skill from samber’s cc-skills-golang collection that trains your coding agent to behave like a careful engineer when production-like failures show up in handlers, services, or databases. Instead of jumping to nil checks or query tweaks, the workflow insists on a failing test that reproduces the bug across input variations, gathers logs and request evidence, and only then applies a minimal fix—often echoing explicit golden rules such as reproduce-before-fix and one-change-at-a-time measurement. Solo builders shipping APIs or CLIs benefit when intermittent 500s, slow queries, or ambiguous errors would otherwise burn context on speculative edits. Use it during Ship when stabilizing tests before release, during Build when backend behavior regresses, and during Operate when parsing live incidents. Outputs are reproducible tests, narrowed root cause, and a measured fix path rather than a pile of unverified diffs.3.7kinstalls18Golang LintGolang Lint is an agent skill that embeds a production-oriented golangci-lint configuration for solo builders shipping Go APIs, workers, and CLIs. Instead of debating which linters to enable on every new repo, you invoke the skill so your coding agent applies a single curated profile spanning correctness (unchecked errors, bad assertions, duration mistakes), deprecation and simplification from staticcheck, and consistent export comments and naming from revive and godot. The config sets tests: true, a five-minute timeout, and max-issues-per-linter at zero so CI and local runs surface the full issue set rather than hiding noise. It fits indie workflows where one person owns backend quality: align local lint with what you want in GitHub Actions, fix findings before review, and keep services deployable without a dedicated platform team. Pair it with your existing test and build skills; this package is the checker layer, not a formatter or test runner.3.7kinstalls19Golang ObservabilityGolang observability is a production-first agent skill for solo builders running Go APIs, CLIs, or workers who need the service observable on day one—not after an outage. It walks through structured logging with slog, Prometheus metric naming and cardinality discipline, OpenTelemetry traces that tie into logs, continuous profiling with pprof and Pyroscope, server-side RUM-style events, alerting hooks, and Grafana dashboards. Use it while you are still in Build when adding features that need spans and RED metrics, again in Ship when hardening launch readiness, and continuously in Operate when tuning alerts and compliance-friendly tracking with a CDP mindset. The persona is explicit: uninstrumented code is treated as incomplete. It deliberately excludes temporary deep performance hunts, which belong in sibling benchmark and performance skills. Expect intermediate Go fluency, golangci-lint-friendly edits, and agent tooling that can run go and bash diagnostics.3.7kinstalls20Golang Dependency Managementgolang-dependency-management is a Go steward skill for solo builders treating every external module as long-term maintenance debt. It walks agents through go.mod hygiene, intentional installs and upgrades, Minimal Version Selection mental models, govulncheck-driven vulnerability passes, outdated module triage, binary size impact, and automated update bots. The persona explicitly challenges whether the standard library already solves the problem before adding packages—a guardrail indie teams need when agents otherwise spam go get. Invoke when you are wiring a new integration, unblocking version conflicts, or standing up Renovate on a single-maintainer repo. Outputs are auditable module changes and documented rationale, not silent dependency growth.3.7kinstalls21Golang Structs InterfacesGolang-structs-interfaces is an agent skill that encodes idiomatic Go API design for solo builders writing services, CLIs, and backend packages. It pushes interfaces to the package that uses them—not the package that implements them—so contracts stay minimal and implementors stay concrete structs. That pattern shows up constantly when wiring a notification service to an email client or similar cross-package dependencies without leaking full client APIs through fat interfaces. Constructors should expose concrete types; callers depend on narrow interfaces they own. Use it during backend implementation and refactors when agents otherwise park interfaces next to implementations or return interface{}-shaped APIs from New functions. It does not replace general Go syntax tutorials; it targets structural decisions that keep modules testable and decoupled.3.7kinstalls22Golang Dependency InjectionGolang Dependency Injection is an agent skill for solo builders shipping Go APIs, CLIs, and small SaaS backends who want maintainable wiring without global variables. It encodes samber’s cc-skills-golang guidance: inject database connections and loggers through constructors, refuse init()-based service bootstrap, and place interfaces where they are consumed so PostgreSQL implementations stay concrete and swappable in tests. The packaged eval scenarios trap common model mistakes—accepting package-level vars or defining UserStore interfaces next to the driver—so Claude Code, Cursor, and Codex produce code you can unit test with fakes. Use it during backend implementation when a service layer grows past a single main.go, or when refactoring legacy Go that leaned on globals. It is intermediate complexity: you should already know basic Go packages and testing. Outcomes are cleaner dependency graphs and constructors that make the next feature (caching, queues, auth middleware) a parameter change, not a repo-wide hunt for hidden state.3.7kinstalls23Golang Cligolang-cli is an agent skill for solo and indie builders who ship Go binaries with spf13/cobra instead of ad-hoc flag parsing. It documents how to structure commands with clear UX, pick the right Args validator or write a custom check, and implement Run handlers that surface failures correctly to the user and CI. The skill emphasizes testability: capture command output in unit tests, keep I/O injectable, and exercise subcommands the same way users invoke them from the shell. That matters when your CLI is the product (devtools, deploy helpers, internal agents) or the entry point for a larger SaaS backend. Use it while you are implementing or refactoring command trees, adding environment-specific deploy commands, or hardening validation before you tag a release. It pairs naturally with Go modules, Makefile or gh-action scripts, and later Ship-phase testing habits without replacing a full cobra generator or enterprise CLI framework.3.7kinstalls24Golang Grpcgolang-grpc is an agent skill for solo and indie builders shipping Go backends that speak protobuf over gRPC. It encodes opinionated patterns from google.golang.org/grpc: listen and serve with graceful shutdown, register services, dial clients with explicit transport credentials, and always surface RPC failures through status.Errorf or status.Error with the right codes package constant. The guide reinforces proto hygiene—wrapper messages for every RPC, google.protobuf.Timestamp for time, and streaming RPCs that match gRPC’s recv/send contracts. Interceptors get first-class treatment so auth and logging wrap handlers without duplicating boilerplate in each method. Use it when you want your coding agent to stop leaking internal errors as codes.Unknown or sketching REST-shaped mistakes inside .proto files. It fits API-first SaaS, platform services, and CLI backends that call remote gRPC endpoints, and pairs naturally with code review or security passes before you ship.3.7kinstalls25Golang Benchmarkgolang-benchmark is an agent skill packaged for Go backends and CLIs where performance claims need trustworthy testing.B benchmarks. The embedded evaluation brief focuses on Go 1.24’s b.Loop() API: setup such as loading a 1MB SHA-256 fixture must sit outside the loop, the loop itself should use b.Loop() rather than idiomatic b.N iteration, and authors should not rely on sink variables because b.Loop() already addresses compiler dead-code elimination. The skill also trains diagnosis when benchmarks look impossibly fast—classic symptom of eliminated work on JSON or hash paths. For solo builders shipping services or tools, this reduces copy-paste benchmark templates that mislead CI and profilers. It pairs with ordinary unit tests but targets micro-benchmark correctness and readability for agent-generated Go code in samber’s cc-skills-golang bundle.3.6kinstalls26Golang Stretchr TestifyGolang Stretchr Testify is an agent skill that encodes how to use github.com/stretchr/testify correctly in Go test files. Indie builders maintaining APIs, workers, or CLIs in Go install it when agents or juniors mix assert and require, flip expected versus actual in Equal, or repeat t on every line. The skill stresses a hard rule: guard parsing and setup with require so a failed precondition stops the test before unsafe assertions run, then use assert for ordinary expectations. It also documents the is and must shorthand from assert.New and require.New to cut verbosity. Eval-style scenarios in the package probe whether the model respects those traps, which makes it useful when you want consistent test output under Claude Code, Cursor, or Codex. It does not replace table-driven test design or integration test harnesses; it sharpens testify usage during Ship when tests are written or refactored.3.6kinstalls27Golang Continuous Integrationgolang-continuous-integration packages a GitHub Actions workflow for AI-assisted code review on Go pull requests using Claude. It triggers on PR lifecycle and review events, groups concurrency per PR, and runs a timeout-bounded quality review job on ubuntu-latest after checkout and Go setup. The workflow documents elevated permissions risks—pull-requests write affects any PR in the repo, and actions read can surface sensitive logs—so solo maintainers can scope triggers to trusted contributors or protected branches. Bot PRs are skipped by default to reduce noise and token spend. Treat this as Ship-phase automation that complements human review: it encodes when to run, what to skip, and how to isolate review jobs rather than replacing security scanning or integration tests.3.6kinstalls28Golang Stay Updatedgolang-stay-updated is a Go-focused agent skill that answers how to follow ecosystem news efficiently when you are a solo builder maintaining backends, CLIs, or small SaaS services in Go. Instead of vague advice to read blogs, it steers you toward named curated newsletters such as Golang Weekly and the Awesome Go Newsletter, explicitly recommending one or two subscriptions so signal stays high and inbox noise stays low. It also maps active community channels—including r/golang, the official Gophers Slack at gophers.slack.com, and related forums beyond Stack Overflow—so you can get release context, module updates, and idiomatic patterns without hours of scrolling. The underlying package includes evaluation assertions that keep recommendations specific and bounded (for example, not dumping more than three or four newsletters). Use it when onboarding to Go, after a long pause from the language, or when you are choosing where to watch breaking changes before a Ship upgrade. It is research and routing knowledge for agents, not an RSS integration.3.5kinstalls29Golang Samber Logolang-samber-lo is an agent skill for solo and indie builders shipping Go APIs and CLIs who already lean on samber/lo. It teaches when collection helpers are appropriate, when the parallel lop package helps CPU-bound work, and when lom micro-optimizations are premature. The skill is built around realistic traps—such as using lop to fan out fifty REST calls—which agents should redirect to errgroup or similar patterns with proper error handling and context. Use it during backend implementation whenever you want generated Go to follow community-safe samber/lo idioms instead of copying parallel utilities into the wrong workload class. It complements generic Go review skills by encoding library-specific semantics that are easy to get wrong in agent-written code.3.4kinstalls30Golang Samber Oopsgolang-samber-oops is an agent skill focused on idiomatic, observability-friendly error handling with the samber/oops library in Go backends. Solo builders shipping APIs, workers, or CLIs install it when agents otherwise interpolate user, tenant, and order IDs into error strings—breaking Sentry or Datadog grouping—or when they mix fmt.Errorf with oops inconsistently. The skill encodes concrete rules: keep message strings static, attach high-cardinality fields through .With(), set scope with .In(), and rely on Wrap’s nil behavior at boundaries. It is backed by explicit evaluation cases (low-cardinality messages, nil wrap passthrough) so agents produce code that survives production incident review. Use during implementation of handlers, repositories, and cross-service calls where error chains must remain searchable and attributable without sacrificing debug context.3.4kinstalls31Golang Samber Sloggolang-samber-slog is an agent skill that teaches solo Go builders how to wire samber’s slog ecosystem into a correct multi-handler pipeline. It focuses on the easy-to-get-wrong details: sampling must be the outermost handler so PII formatting and routing never run on records that sampling will drop, sampling must come from slog-sampling rather than ad-hoc counters, and multi-destination routing must use slog-multi patterns that match product intent—whether every matching rule fires or only the first match wins. The skill is for indie developers shipping APIs or CLIs who already use structured logging but need Sentry, scrubbing, and cost-aware volume control in one composition. Invoke it when scaffolding observability for a new service, refactoring a tangled slog setup, or debugging duplicate alerts because ERROR logs hit both PagerDuty and Slack. It turns generic slog advice into library-specific, eval-verified handler chains your coding agent can reproduce consistently.3.4kinstalls32Golang Samber Rogolang-samber-ro is an agent skill that encodes procedural knowledge for Samber’s Go reactive library samber/ro. Solo and indie builders shipping Go APIs or workers install it when agents otherwise default to untyped pipes, slice-style lo operators on observables, or incomplete observers missing error handlers. The skill emphasizes typed multi-step pipes, explicit predicates and maps, and the architectural boundary: synchronous samber/lo for in-memory slice transforms, samber/ro when the source is or becomes a stream. Eval fixtures in the package stress Interval subscriptions and mixed workloads so codegen matches library idioms. Use during backend implementation whenever chat models hallucinate generic Pipe signatures or skip onError callbacks that leave production goroutines hanging.3.4kinstalls33Golang Samber Mogolang-samber-mo is an agent skill that helps solo Go builders replace pointer-based nullable fields with samber/mo Option types when one struct must round-trip through PostgreSQL (or similar) and JSON REST responses. The common trap is sticking with *string because it compiles everywhere, then fighting ambiguous JSON or maintaining duplicate DTOs with sql.NullString. This skill teaches that mo.Option[T] implements the database interfaces and JSON interfaces together, so phone, bio, and other optional columns stay type-safe and explicit in application code. It is ideal when you are extending an existing service’s User model or designing new resources where absence, null, and present values need clear API contracts. Complexity stays intermediate: you already know Go and SQL scanning, but want agent-generated structs and explanations that match library best practices. Use it during handler and repository work—not as a standalone migration tool—so generated code matches how mo.Option composes with filters, updates, and partial PATCH payloads.3.4kinstalls34Golang Samber Hotgolang-samber-hot teaches agents how to construct and operate Samber’s hot in-memory cache for Go services. Indie API authors install it when models otherwise pick familiar LRU, omit janitor shutdown, or split builder methods incorrectly. The skill encodes algorithm selection: W-TinyLFU for blended hot-and-cold key patterns common in profile or session caches; LFU when the workload is explicitly frequency-dominated and stable. Implementation detail covers generic NewHotCache, chained WithTTL and WithJanitor, mandatory Build(), and defer StopJanitor() for clean process exit. Bundled evals mirror real prompts—50k-entry TTL caches and DNS resolver power-law domains—so generated code matches library expectations rather than copied memcache snippets from other languages.3.4kinstalls35Golang Graphqlgolang-graphql is an agent skill aimed at solo builders shipping Go GraphQL APIs who need resolver code that survives production traffic. Its embedded evals stress gqlgen conventions: parent `obj *model.User` signatures, fetching related posts through a DataLoader injected per HTTP request, and never issuing bare database calls inside resolver methods—a common N+1 failure mode. A second scenario targets graph-gophers/graphql-go for computed fields like non-nullable `commentCount` on posts. The skill is structured as testable expectations rather than a long narrative, which makes it well suited for agents that must generate resolver stubs, middleware wiring, and loader batch functions that match community best practice. Use it when you are extending an existing Go GraphQL service and want generated code reviewed against explicit batching and context rules before merge.2kinstalls36Golang Uber Fxgolang-uber-fx teaches coding agents to architect Go services with uber-go/fx: reflection-based DI on dig, modular fx.Module boundaries, lifecycle hooks for boot and graceful shutdown, and structured event logging. Solo builders reach for it when imports include go.uber.org/fx or when they are adopting fx for a long-running API, worker, or CLI service that must start and stop cleanly. The skill persona treats the composition root as the only wiring surface, favors modules as reuse units, and defers non-lifecycle DI questions to the sibling dig skill. It supports Claude Code and similar agents with MIT-licensed guidance from samber’s cc-skills-golang library. Intermediate complexity reflects reflection, annotate semantics, and shutdown ordering. Use during backend implementation and refactors—not for greenfield language tutorials without an fx dependency.1.9kinstalls37Golang Swaggergolang-swagger is an agent skill for solo builders shipping Go HTTP services who want Swagger UI that matches real handlers. It walks through the easy-to-miss Gin setup: importing the generated docs package as a blank import, registering gin-swagger routes, and keeping swag annotations honest when response types are maps or other shapes swag cannot infer. The bundled evals stress common traps—empty Swagger UI despite a registered route, and @Success lines that reference raw map types instead of named structs or swaggertype hints. Use it during backend build when you already ran swag init or when you are documenting feature-flag-style JSON. It keeps API contracts visible for agents, mobile clients, and future you without maintaining a separate OpenAPI file by hand.1.9kinstalls38Golang Uber Diggolang-uber-dig is a focused agent skill from Samber’s Go skill pack that teaches uber-go/dig patterns solo builders need when a service’s constructor graph outgrows readable function signatures. It addresses real traps—long NewServer parameter lists, ad-hoc config structs that dig cannot populate, and multiple HTTP handlers that must register into a shared router slice via value groups. Use while scaffolding APIs, CLIs, or workers where compile-time wiring and testable modules matter more than manual singletons. The published eval fixtures stress dig.In embedding, single-argument constructors, and rejecting answers that keep flat parameter lists or non-dig structs. Pair with broader Go layout and testing skills after the container graph is stable.1.9kinstalls39Golang Spf13 Cobragolang-spf13-cobra is an agent skill that encodes spf13/cobra best practices for solo Go developers building command-line tools. It steers agents toward RunE handlers that return errors to Cobra’s exit path, declarative argument validation via cobra’s Args helpers, and clean separation between CLI wiring and business logic. The bundled eval fixtures describe common traps — recommending Run with manual exit, or in-handler len(args) guards — so the skill functions as procedural knowledge plus implicit quality gates when you generate or review CLI code. Use it while implementing new subcommands, refactoring legacy CLIs, or when an agent keeps suggesting patterns that break testability and proper exit codes. It does not replace reading Cobra’s upstream docs for advanced features like persistent flags or completion, but it narrows day-one scaffolding to patterns that survive code review and production ops.1.9kinstalls40Golang Spf13 Vipergolang-spf13-viper is an agent skill aimed at solo builders shipping Go APIs and CLIs who standardize on Viper for configuration but keep hitting subtle library behavior. It focuses on production-grade patterns: mapping nested dotted keys to underscore environment variables via SetEnvKeyReplacer, combining SetEnvPrefix and AutomaticEnv correctly, and safely handling Sub() when subtrees may not exist. The bundled eval scenarios stress common traps—models that suggest renaming keys or re-reading files instead of fixing replacers, or ignoring nil sub-vipers. Use it during backend implementation when wiring twelve-factor config, multi-environment deploys, or shared modules that expose nested settings. It is library-specific procedural knowledge, not a generic config abstraction, and expects familiarity with Go module layout and service bootstrapping.1.9kinstalls41Golang Google Wiregolang-google-wire is an agent skill that teaches correct google/wire dependency injection patterns for solo builders shipping Go APIs and CLIs. When wire generate succeeds but go build fails with redeclared InitApp, the skill points to the missing //go:build wireinject tag so only wire_gen.go enters the binary. It also covers organizing provider sets, binding interfaces to implementations, and avoiding traps like deleting generated code or shuffling packages without fixing the build constraint. Use it while scaffolding a new service graph or debugging injector files in an existing repo. The focus is procedural backend structure—not product discovery or deployment—so it sits squarely in implementation time with your Go module open.1.8kinstalls