Skip to content
Back to search

cc-skills-golang

AI Agent Skills for production-ready Go projects

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/samber-cc-skills-golang/badge.svg)](/listings/samber-cc-skills-golang)

HTML

<a href="/listings/samber-cc-skills-golang"><img src="/api/listings/samber-cc-skills-golang/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

`golang-cli`

Go CLI application development. Project layout, exit codes, signal handling, I/O patterns, argument parsing, and terminal UX.

`golang-continuous-integration`

CI/CD pipeline configuration for Go projects using GitHub Actions. Build, test, lint, and release workflows.

`golang-dependency-management`

Go module dependency strategies. go.mod conventions, versioning, replace directives, tool dependencies, and multi-module workspaces.

`golang-gopls`

Semantic code intelligence for your local build via `gopls`, the official Go language server. Go-to-definition, find references, call/implementation hierarchy, workspace symbol search, diagnostics, safe rename, and refactors (extract/inline/fill/rewrite). Reachable via gopls's own MCP server, Claude Code's native `LSP` tool, or the `gopls` CLI.

`golang-pkg-go-dev`

Go package and module exploration via `godig`, a pkg.go.dev API client (CLI + MCP server). Package docs, API references, symbols, code examples, versions, importers, licenses, and known vulnerabilities. Prefer over Context7 for Go packages.

`golang-popular-libraries`

Curated recommendations for production-ready Go libraries and frameworks. When the stdlib is enough vs when to reach for a package.

`golang-project-layout`

Go project structure and workspace setup. cmd/internal/pkg conventions, monorepo layout, CLI project structure, and when to keep things flat.

`golang-stay-updated`

Resources to stay current with Go. Official channels, community hubs, key people to follow, and learning resources.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/plugin.json · Manifest · 27 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "cc-skills-golang",
  3. "description": "AI Agent Skills for production-ready Go projects",
  4. "version": "2.0.1",
  5. "author": {
  6. "name": "Samuel Berthe",
  7. "email": "hey@samuel-berthe.fr"
  8. },
  9. "homepage": "https://github.com/samber/cc-skills-golang",
  10. "repository": "https://github.com/samber/cc-skills-golang",
  11. "license": "MIT",
  12. "icon": "./assets/cc-skills-golang-logo-512.png",
  13. "keywords": [
  14. "claude-code",
  15. "claude-code-plugin",
  16. "plugin",
  17. "go",
  18. "golang",
  19. "ai-agent",
  20. "skills",
  21. "agentic",
  22. "engineering",
  23. "developer",
  24. "coding",
  25. "productivity"
  26. ]
  27. }
README.md · README · 500 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Agent Skills for production-ready Golang projects
  2. AI agent skills are reusable instruction sets that extend your coding assistant with domain-specific expertise, loaded on demand so they don't bloat your context. This repository covers **Go-specific** skills only (language, testing, security, observability, etc.); for dev workflow skills (git conventions, CI/CD, PR reviews) you'll want to add a separate skills plugin.
  3. For non-Golang skills, please visit [cc-skills](https://github.com/samber/cc-skills).
  4. <!-- prettier-ignore-start -->
  5. > [!IMPORTANT]
  6. > Bootstrapped with Claude Code by distilling my Go project commits. **Edited, tested, reviewed and reworked by a human**.
  7. >
  8. > **No AI slop here.** AI-made skills are useless.
  9. >
  10. > Built for Claude Code, Codex, Gemini, Copilot, Antigravity, Cursor...
  11. <!-- prettier-ignore-end -->
  12. <img width="1414" height="491" alt="image" src="https://github.com/user-attachments/assets/620b5835-c1ba-4ea9-bf47-2293b58b879e" />
  13. ## 🚀 How to use
  14. **Install with [skills](https://skills.sh/) CLI** (universal, works with any [Agent Skills](https://agentskills.io)-compatible tool):
  15. ```bash
  16. npx skills add https://github.com/samber/cc-skills-golang --all
  17. # or a single skill:
  18. npx skills add https://github.com/samber/cc-skills-golang --skill golang-performance
  19. ```
  20. <!-- prettier-ignore-start -->
  21. <details>
  22. <summary>Claude Code</summary>
  23. ```bash
  24. /plugin marketplace add samber/cc
  25. /plugin install cc-skills-golang@samber
  26. ```
  27. </details>
  28. <details>
  29. <summary>Openclaw</summary>
  30. Copy skills into the cross-client discovery directory:
  31. ```bash
  32. git clone https://github.com/samber/cc-skills-golang.git ~/.openclaw/skills/cc-skills-golang
  33. # or in workspace:
  34. git clone https://github.com/samber/cc-skills-golang.git ~/.openclaw/workspace/skills/cc-skills-golang
  35. ```
  36. </details>
  37. <details>
  38. <summary>Gemini CLI</summary>
  39. ```bash
  40. gemini extensions install https://github.com/samber/cc-skills-golang
  41. ```
  42. Update with `gemini extensions update cc-skills-golang`.
  43. </details>
  44. <details>
  45. <summary>Cursor</summary>
  46. Copy skills into the cross-client discovery directory:
  47. ```bash
  48. git clone https://github.com/samber/cc-skills-golang.git ~/.cursor/skills/cc-skills-golang
  49. ```
  50. Cursor auto-discovers skills from `.agents/skills/` and `.cursor/skills/`.
  51. </details>
  52. <details>
  53. <summary>Copilot</summary>
  54. Copy skills into the cross-client discovery directory:
  55. ```bash
  56. /plugin install https://github.com/samber/cc-skills-golang
  57. # or
  58. git clone https://github.com/samber/cc-skills-golang.git ~/.copilot/skills/cc-skills-golang
  59. ```
  60. Copilot auto-discovers skills from `.copilot/skills/`.
  61. </details>
  62. <details>
  63. <summary>OpenCode</summary>
  64. Copy skills into the cross-client discovery directory:
  65. ```bash
  66. git clone https://github.com/samber/cc-skills-golang.git ~/.agents/skills/cc-skills-golang
  67. ```
  68. OpenCode auto-discovers skills from `.agents/skills/`, `.opencode/skills/`, and `.claude/skills/`.
  69. </details>
  70. <details>
  71. <summary>Codex (OpenAI)</summary>
  72. Install the plugin via the Codex CLI:
  73. ```bash
  74. codex plugin add github:samber/cc-skills
  75. ```
  76. Update with `codex plugin update cc-skills`. Falls back to a manual clone if the marketplace path is unavailable:
  77. ```bash
  78. git clone https://github.com/samber/cc-skills.git ~/.agents/skills/cc-skills
  79. ```
  80. Codex auto-discovers skills from `~/.agents/skills/` and `.agents/skills/`.
  81. </details>
  82. <details>
  83. <summary>Antigravity</summary>
  84. Clone and symlink into the cross-client discovery path:
  85. ```bash
  86. git clone https://github.com/samber/cc-skills-golang.git ~/.antigravity/skills/cc-skills-golang
  87. ```
  88. Update with `cd ~/.antigravity/skills/cc-skills-golang && git pull`.
  89. </details>
  90. <!-- prettier-ignore-end -->
  91. ## 🧩 Skills
  92. These skills are designed as **atomic, cross-referencing units**. A skill may reference conventions defined in another (e.g. error-handling rules that affect logging live in `golang-error-handling`, not `golang-observability`). Installing only a subset will give you a partial and potentially inconsistent view of the guidelines. For best results, install all general-purpose skills together.
  93. ```
  94. ┌────────────────────────────────────────┐
  95. │ Golang Skills │
  96. └──────────────────┬─────────────────────┘
  97. │
  98. ┌─────────────────┬──────────────────────┼──────────────────────┐
  99. ▼ ▼ ▼ ▼
  100. ┌──────────────┐ ┌──────────────┐ ┌─────────────────┐ ┌──────────────────────┐
  101. │ Code Quality │ │ Arch & Design│ │ QA & Perf │ │ Project Start │
  102. ├──────────────┤ ├──────────────┤ ├─────────────────┤ ├──────────────────────┤
  103. │ code-style │ │ design-patt │ │ testing │ │ project-layout │
  104. │ naming │ │ concurrency │ │ benchmark │ │ popular-libs │
  105. │ error-handl │ │ context │ │ performance │ │ cli │
  106. │ safety │ │ dep-inject │ │ troubleshoot │ │ continuous-integ. │
  107. │ structs-iface│ │ data-structs │ │ observability │ │ stay-updated │
  108. │ documentation│ │ database │ │ │ │ dep-management │
  109. │ lint │ │ modernize │ │ │ │ gopls │
  110. │ security │ │ refactoring │ │ │ │ pkg-go-dev │
  111. └──────────────┘ └──────────────┘ └─────────────────┘ └──────────────────────┘
  112. ┌─────────────────────────────────────────────────────────────────────────┐
  113. │ Framework / Library Skills │
  114. ├──────────────┬────────────────┬──────────────┬─────────────┬───────────┤
  115. │ APIs │ DI │ Frameworks │ samber/* │ Testing │
  116. ├──────────────┼────────────────┼──────────────┼─────────────┼───────────┤
  117. │ grpc │ google-wire │ spf13-cobra │ samber-lo │ stretchr- │
  118. │ graphql │ uber-dig │ spf13-viper │ samber-mo │ testify │
  119. │ swagger │ uber-fx │ │ samber-ro │ │
  120. │ │ │ │ samber-do │ │
  121. │ │ │ │ samber-hot │ │
  122. │ │ │ │ samber-slog │ │
  123. │ │ │ │ samber-oops │ │
  124. └──────────────┴────────────────┴──────────────┴─────────────┴───────────┘
  125. ```
  126. - ⭐️ Recommended
  127. - ✅ Published
  128. - 👷 Work in progress
  129. - ❌ To-do
  130. - ⚡ Command available
  131. - 🧠 Ultrathink automatically
  132. - 🤖 Ultracode automatically
  133. - ⚙️ Overridable (see doc below)
  134. - **Description (tok)**: weight of the `description` field from YAML frontmatter, always loaded into Claude's context for skill triggering
  135. - **SKILL.md (tok)**: weight of the full `SKILL.md` file loaded when the skill triggers
  136. - **Directory (tok)**: weight of all files in the skill directory (SKILL.md + referenced markdown files)
  137. **General purpose:**
  138. <!-- markdownlint-disable table-column-style -->
  139. | | Skill | Flags | Error rate gap | Description (tok) | SKILL.md (tok) | Directory (tok) |
  140. | --- | --- | --- | --- | --- | --- | --- |
  141. | ⭐️ | ✅ `golang-code-style` | ⚡ 🤖 ⚙️ | -40% | 114 | 2,358 | 2,974 |
  142. | ⭐️ | ✅ `golang-data-structures` | ⚡ | -39% | 93 | 2,608 | 6,327 |
  143. | ⭐️ | ✅ `golang-database` | ⚡ ⚙️ | -38% | 97 | 2,721 | 7,243 |
  144. | ⭐️ | ✅ `golang-design-patterns` | ⚡ ⚙️ | -37% | 80 | 2,694 | 9,400 |
  145. | ⭐️ | ✅ `golang-documentation` | ⚡ 🤖 ⚙️ | -53% | 75 | 3,163 | 11,876 |
  146. | ⭐️ | ✅ `golang-error-handling` | ⚡ 🤖 ⚙️ | -26% | 141 | 1,734 | 4,693 |
  147. | ⭐️ | ✅ `golang-how-to` | ⚡ | — | 184 | 4,210 | 17,583 |
  148. | ⭐️ | ✅ `golang-modernize` | ⚡ 🤖 | -43% | 104 | 3,486 | 15,145 |
  149. | ⭐️ | ✅ `golang-naming` | ⚡ ⚙️ | -23% | 159 | 3,031 | 7,399 |
  150. | ⭐️ | ✅ `golang-refactoring` | ⚡ 🧠 🤖 ⚙️ | — | 245 | 3,835 | 20,392 |
  151. | ⭐️ | ✅ `golang-safety` | ⚡ | -58% | 78 | 2,614 | 5,384 |
  152. | ⭐️ | ✅ `golang-testing` | ⚡ 🧠 🤖 ⚙️ | -32% | 115 | 4,270 | 8,822 |
  153. | ⭐️ | ✅ `golang-troubleshooting` | ⚡ 🧠 🤖 | -32% | 173 | 2,993 | 18,035 |
  154. | ⭐️ | ✅ `golang-security` | ⚡ 🧠 🤖 | -32% | 85 | 3,187 | 21,623 |
  155. | | ✅ `golang-benchmark` | ⚡ 🧠 | -50% | 102 | 3,153 | 33,396 |
  156. | | ✅ `golang-cli` | ⚡ | -43% | 125 | 2,338 | 6,153 |
  157. | | ✅ `golang-concurrency` | ⚡ 🤖 ⚙️ | -39% | 72 | 2,196 | 6,826 |
  158. | | ✅ `golang-context` | ⚡ ⚙️ | -34% | 82 | 1,211 | 4,021 |
  159. | | ✅ `golang-continuous-integration` | ⚡ | -59% | 177 | 3,542 | 12,804 |
  160. | | ✅ `golang-dependency-injection` | ⚡ 🤖 ⚙️ | -47% | 178 | 3,016 | 5,287 |
  161. | | ✅ `golang-dependency-management` | ⚡ | -54% | 77 | 2,407 | 5,545 |
  162. | | ✅ `golang-structs-interfaces` | ⚡ ⚙️ | -35% | 111 | 3,076 | 3,076 |
  163. | | ✅ `golang-lint` | ⚡ 🤖 | -41% | 98 | 1,877 | 6,295 |
  164. | | ✅ `golang-observability` | ⚡ 🤖 ⚙️ | -37% | 164 | 3,128 | 19,583 |
  165. | | ✅ `golang-performance` | ⚡ 🧠 🤖 | -39% | 130 | 2,226 | 19,820 |
  166. | | ✅ `golang-gopls` | ⚡ | — | 219 | 2,317 | 12,312 |
  167. | | ✅ `golang-pkg-go-dev` | ⚡ | — | 170 | 3,442 | 5,386 |
  168. | | ✅ `golang-popular-libraries` | ⚡ | -30% | 156 | 1,181 | 5,093 |
  169. | | ✅ `golang-project-layout` | ⚡ | -38% | 105 | 1,761 | 6,257 |
  170. | | ✅ `golang-stay-updated` | ⚡ | -56% | 44 | 1,802 | 1,802 |
  171. **Tools:**
  172. | Skill | Flags | Error rate gap | Description (tok) | SKILL.md (tok) | Directory (tok) |
  173. | --- | --- | --- | --- | --- | --- |
  174. | ✅ `golang-google-wire` | ⚡ | -16% | 122 | 2,670 | 7,400 |
  175. | ✅ `golang-graphql` | | -16% | 76 | 3,070 | 7,941 |
  176. | ✅ `golang-grpc` | ⚡ | -41% | 70 | 2,341 | 5,157 |
  177. | ✅ `golang-spf13-cobra` | ⚡ | — | 176 | 2,580 | 7,351 |
  178. | ✅ `golang-spf13-viper` | ⚡ | — | 170 | 2,551 | 7,098 |
  179. | ✅ `golang-swagger` | ⚡ | — | 144 | 2,342 | 3,347 |
  180. | ✅ `golang-uber-dig` | ⚡ | -10% | 107 | 2,585 | 6,257 |
  181. | ✅ `golang-uber-fx` | ⚡ | -5% | 118 | 2,825 | 7,060 |
  182. | ✅ `golang-samber-do` | ⚡ | -81% | 71 | 2,145 | 3,660 |
  183. | ✅ `golang-samber-hot` | ⚡ | -54% | 119 | 1,986 | 7,416 |
  184. | ✅ `golang-samber-lo` | ⚡ | -40% | 166 | 2,610 | 10,288 |
  185. | ✅ `golang-samber-mo` | ⚡ 🧠 | -48% | 82 | 2,967 | 11,382 |
  186. | ✅ `golang-samber-oops` | ⚡ | -59% | 70 | 2,544 | 2,856 |
  187. | ✅ `golang-samber-ro` | ⚡ 🧠 | -50% | 153 | 2,976 | 11,192 |
  188. | ✅ `golang-samber-slog` | ⚡ | -19% | 119 | 3,120 | 9,842 |
  189. | ❌ `golang-temporal` | | — | 0 | 0 | 0 |
  190. | ✅ `golang-stretchr-testify` | ⚡ | -47% | 92 | 1,858 | 2,677 |
  191. ## 🧪 Skill evaluations
  192. | | With Skill | Without Skill | Delta |
  193. | ----------- | ------------------- | ------------------- | --------- |
  194. | **Overall** | **3348/3439 (97%)** | **1957/3439 (57%)** | **+40pp** |
  195. See [EVALUATIONS.md](./EVALUATIONS.md) for the full per-skill breakdown.
  196. ## 📖 Skills description
  197. ### Code Quality
  198. #### `golang-code-style`
  199. Go code formatting and conventions. gofmt, goimports, linting rules, comment conventions, and project-level style consistency. Overridable by company skills.
  200. #### `golang-documentation`
  201. Go documentation standards. Package docs, godoc conventions, code comments, example functions, README structure, and API reference generation. Overridable.
  202. #### `golang-error-handling`
  203. Go error handling best practices. Error creation, wrapping with fmt.Errorf and errors.Is/As, sentinel errors, custom error types, error codes, and panic recovery. Overridable.
  204. #### `golang-lint`
  205. Go linting best practices and golangci-lint configuration. Presets, custom rules, CI integration, inline suppression, and output interpretation.
  206. #### `golang-naming`
  207. Go naming conventions across all identifier types. Packages, constructors, structs, interfaces, constants, errors, receivers, acronyms, test functions. Covers MixedCaps rules, Get-prefix, and utils/helpers anti-patterns. Overridable.
  208. #### `golang-safety`
  209. Defensive Go coding. Prevents panics, silent data corruption, and runtime bugs. nil safety, append aliasing, map concurrent access, float comparison, zero-value design, numeric overflow.
  210. #### `golang-security`
  211. Go security best practices. Injection prevention (SQL, command, XSS), cryptography, filesystem/network safety, secrets management, cookie security, and tool configuration. Audit and review modes.
  212. #### `golang-structs-interfaces`
  213. Go struct and interface design. Composition, embedding, type assertions, interface segregation, struct tags (JSON/YAML/DB), pointer vs value receivers. Overridable.
  214. ### Architecture & Design
  215. #### `golang-concurrency`
  216. Go concurrency patterns. Goroutines, channels, sync primitives, context cancellation, worker pools, fan-out/fan-in, pipelines. Overridable.
  217. #### `golang-context`
  218. Idiomatic context.Context usage. Creation, cancellation, timeouts, values, propagation patterns, and common anti-patterns. Overridable.
  219. #### `golang-data-structures`
  220. Go data structures internals and usage. Slices (capacity growth, append aliasing), maps, channels, sync primitives, and when to use each.
  221. #### `golang-database`
  222. Go database access patterns. Parameter binding, connection pooling, transactions, migrations, sqlboiler/sqlc code generation, query builders. Overridable.
  223. #### `golang-dependency-injection`
  224. Dependency injection patterns in Go. Constructor injection, interface-based DI, wire/dig/fx comparison, and when DI is worth the complexity. Overridable.
  225. #### `golang-design-patterns`
  226. Idiomatic Go design patterns. Functional options, constructors, builder pattern, middleware chains, circuit breaker, and architecture guides with file trees and code. Overridable.
  227. #### `golang-modernize`
  228. Modernize Go code to use recent language features. Range-over-int, min/max builtins, iterators, slices/maps/cmp/slog stdlib packages, testing patterns (t.Context, b.Loop, synctest), and tooling upgrades.
  229. #### `golang-refactoring`
  230. Safe, at-scale refactoring process for existing Go code. Coverage-adaptive safety net, tool-driven behavior-preserving transforms (gopls Rename/Inline/Extract, gofmt -r, eg, gopatch), the Fowler catalog mapped to Go, breaking import cycles, type-alias gradual code repair, and a human-in-the-loop workflow of staged PRs on a refactoring branch.
  231. ### QA & Performance
  232. #### `golang-benchmark`
  233. Go benchmarking, profiling, and performance measurement. pprof, trace, CPU/memory/block profiles, flame graphs, benchmark comparison (benchstat), continuous profiling.
  234. #### `golang-observability`
  235. Go production observability. Structured logging (slog), Prometheus metrics, OpenTelemetry tracing, pprof profiling, RUM tracking, alerting, Grafana dashboards. Overridable.
  236. #### `golang-performance`
  237. Go performance optimization. Allocation reduction, CPU efficiency, memory layout, GC tuning, pooling, caching, hot-path optimization. Review and hot-path modes.
  238. #### `golang-testing`
  239. Production-ready Go tests. Table-driven tests, fuzzing, fixtures, goroutine leak detection (goleak), snapshot testing, code coverage, integration tests, parallel tests. Overridable.
  240. #### `golang-troubleshooting`
  241. Systematic Go debugging methodology. Common pitfalls, test-driven debugging, pprof capture, Delve debugger, race detection, GODEBUG tracing, production debugging.
  242. ### Project Setup
  243. #### `golang-cli`
  244. Go CLI application development. Project layout, exit codes, signal handling, I/O patterns, argument parsing, and terminal UX.
  245. #### `golang-continuous-integration`
  246. CI/CD pipeline configuration for Go projects using GitHub Actions. Build, test, lint, and release workflows.
  247. #### `golang-dependency-management`
  248. Go module dependency strategies. go.mod conventions, versioning, replace directives, tool dependencies, and multi-module workspaces.
  249. #### `golang-gopls`
  250. Semantic code intelligence for your local build via `gopls`, the official Go language server. Go-to-definition, find references, call/implementation hierarchy, workspace symbol search, diagnostics, safe rename, and refactors (extract/inline/fill/rewrite). Reachable via gopls's own MCP server, Claude Code's native `LSP` tool, or the `gopls` CLI.
  251. #### `golang-pkg-go-dev`
  252. Go package and module exploration via `godig`, a pkg.go.dev API client (CLI + MCP server). Package docs, API references, symbols, code examples, versions, importers, licenses, and known vulnerabilities. Prefer over Context7 for Go packages.
  253. #### `golang-popular-libraries`
  254. Curated recommendations for production-ready Go libraries and frameworks. When the stdlib is enough vs when to reach for a package.
  255. #### `golang-project-layout`
  256. Go project structure and workspace setup. cmd/internal/pkg conventions, monorepo layout, CLI project structure, and when to keep things flat.
  257. #### `golang-stay-updated`
  258. Resources to stay current with Go. Official channels, community hubs, key people to follow, and learning resources.
  259. ### APIs
  260. #### `golang-graphql`
  261. GraphQL API development in Go using gqlgen/graphql-go. Schema definition, resolvers, subscriptions, dataloader, and federation.
  262. #### `golang-grpc`
  263. gRPC in Go. Protobuf organization, service definitions, streaming, interceptors, error codes, and code generation workflow.
  264. #### `golang-swagger`
  265. OpenAPI/Swagger docs with swaggo/swag. Annotation comments, code generation, framework integrations (gin, echo, fiber, chi), security definitions.
  266. ### Dependency Injection
  267. #### `golang-google-wire`
  268. Compile-time dependency injection with google/wire. Provider sets, injector generation, wire.Build, and structured DI patterns.
  269. #### `golang-uber-dig`
  270. Reflection-based DI with uber-go/dig. Provide/Invoke, dig.In/dig.Out, named values, value groups, optional dependencies, and Decorate.
  271. #### `golang-uber-fx`
  272. Application framework with uber-go/fx. fx.New, fx.Provide/Invoke, fx.Module, lifecycle hooks, fx.Annotate, fx.Decorate, signal-aware Run.
  273. ### Frameworks
  274. #### `golang-spf13-cobra`
  275. CLI command trees with spf13/cobra. Command hierarchy, RunE hooks, flag management, shell completion, usage templates, and testing with SetArgs.
  276. #### `golang-spf13-viper`
  277. Layered configuration with spf13/viper. Flag > env > file > KV > default precedence, BindPFlag, hot reload, test isolation, and remote KV integration.
  278. ### samber/\*
  279. #### `golang-samber-do`
  280. Dependency injection with samber/do. Type-safe service containers, lifecycle management, scopes, health checks, and graceful shutdown.
  281. #### `golang-samber-hot`
  282. In-memory caching with samber/hot. 9 eviction algorithms (LRU, LFU, TinyLFU, W-TinyLFU, S3FIFO, ARC, SIEVE...), TTL, loaders, sharding, stale-while-revalidate, Prometheus metrics.
  283. #### `golang-samber-lo`
  284. Functional programming helpers with samber/lo. 500+ type-safe generic functions for slices, maps, channels, strings. Immutable (lo), parallel (lop), mutable (lom), iterators (loi), SIMD.
  285. #### `golang-samber-mo`
  286. Monadic types with samber/mo. Option, Result, Either, Future, IO, Task, State for type-safe nullable values, error handling, and functional composition.
  287. #### `golang-samber-oops`
  288. Structured error handling with samber/oops. Error builders, stack traces, error codes, context attributes, public vs developer messages, panic recovery, and APM integration.
  289. #### `golang-samber-ro`
  290. Reactive streams with samber/ro. 150+ type-safe operators, cold/hot observables, 5 subject types, 40+ plugins, automatic backpressure, and Go context integration.
  291. #### `golang-samber-slog`
  292. Structured logging pipeline with samber/slog-\*\*\*\* packages. Multi-handler routing (slog-multi), sampling, formatting, HTTP middleware, and 20+ backend sinks.
  293. ### Testing
  294. #### `golang-stretchr-testify`
  295. Testing with stretchr/testify. assert, require, mock, and suite packages. Assertions, mock expectations, argument matchers, suite lifecycle, and custom matchers.
  296. ## 🕵 Use in CI for AI-driven reviews
  297. Add AI agents as PR reviewers alongside traditional static analysis. When configured with this skill plugin, the agent applies the relevant Go skills per review area — catching architectural drift, logic bugs, and concurrency hazards that linters cannot detect.
  298. See [GOLANG-AI-DRIVEN-REVIEW.md](./GOLANG-AI-DRIVEN-REVIEW.md) for full setup instructions (Claude Code Action and GitHub Copilot).
  299. ## 🎯 Tuning Skill Triggers
  300. If a skill triggers too often or not often enough, please [open an issue](https://github.com/samber/cc-skills-golang/issues) suggesting a description change. The `description` field in SKILL.md frontmatter is the primary triggering mechanism — small wording adjustments can significantly improve trigger accuracy. Some `SKILL.md` files might have a `When to use` section which is another level of exclusion. Finally, `SKILL.md` files are an entrypoint for lazy loading references with deep knowledge located in `references/`.
  301. ## 🔄 Overlap
  302. Claude reports very little overlap between skills in this repo, thanks to cross-reference. I suggest enabling most of the skills and leveraging lazy loading. The recommended ⭐️ skills load ~1,100 tokens of descriptions at startup; full skill content is only pulled in when relevant. Note:
  303. - I estimate that 50% of `golang-naming` and `golang-code-style` overlap with linters (golangci-lint).
  304. - A large part of the security rules in `golang-security` have been distilled from the Bearer (SAST) checklist. The skill is still useful for methodology.
  305. - If your team has its own conventions, create a company skill and declare the override explicitly near the top of its body: `This skill supersedes samber/cc-skills-golang@golang-naming skill for [company] projects.` Skills marked ⚙️ in the table above support this mechanism.
  306. ## ✍️ Contribute
  307. - **100 tokens per skill description** - what? when to use this skill?
  308. - **1.000–2.500 tokens per SKILL.md** — keep the main file focused on essentials
  309. - **Use secondary markdown files for depth** — reference them from SKILL.md with relative links (e.g., `[Logging](./logging.md)`). Claude reads these on demand when the topic is relevant, so they don't count against the context budget until needed
  310. - **Up to 10.000 tokens** for full skill and secondary files
  311. - **2–4 skills loaded simultaneously** in a typical session — design skills to coexist
  312. - **Stay below ~10k tokens of total loaded SKILL.md** anytime to avoid degrading response quality
  313. For more guidelines, please check `CLAUDE.md`.
  314. ## 💫 Fuel the Revolution
  315. - ⭐️ **Star this repo** - Your star powers the caffeine engine!
  316. - ☕️ **Buy me a coffee** - I'll literally use it to build more skills while drinking actual coffee
  317. [![GitHub Sponsors](https://img.shields.io/github/sponsors/samber?style=for-the-badge)](https://github.com/sponsors/samber)
  318. ## 📝 License
  319. Copyright © 2026 [Samuel Berthe](https://github.com/samber).
  320. This project is under [MIT](./LICENSE) license.

Version history

  • v2.0.111/9/2026

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.