Skip to content
Back to search

eduardo-sl

SkillGitHubIncomplete

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/eduardo-sl--go-agent-skills/badge.svg)](/listings/eduardo-sl--go-agent-skills)

HTML

<a href="/listings/eduardo-sl--go-agent-skills"><img src="/api/listings/eduardo-sl--go-agent-skills/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.

Install with the [`npx skills`](https://skills.sh) CLI. It detects the agents you have and puts each skill where that agent looks for it. That covers **Claude Code**, **Cursor**, **Codex**, **GitHub Copilot**, **Windsurf**, **OpenCode**, **Cline**, and [37+ more agents](https://github.com/vercel-labs/skills#available-agents).

# Everything, interactive
npx skills add eduardo-sl/go-agent-skills

# Look before you install
npx skills add eduardo-sl/go-agent-skills --list

# Only the skills you want
npx skills add eduardo-sl/go-agent-skills --skill go-code-review --skill go-defensive-coding

# Globally, for every project
npx skills add eduardo-sl/go-agent-skills -g

# Non-interactive, for CI and dotfiles
npx skills add eduardo-sl/go-agent-skills --all -y

<details> <summary><b>Claude Code</b>: plugin marketplace</summary>

/plugin marketplace add eduardo-sl/go-agent-skills
/plugin install go-agent-skills@eduardo-sl

Or install the files directly: `npx skills add eduardo-sl/go-agent-skills -a claude-code`

</details>

<details> <summary><b>Cursor</b></summary>

npx skills add eduardo-sl/go-agent-skills -a cursor

Cursor auto-discovers skills from `.cursor/skills/` and `.agents/skills/`.

</details>

<details> <summary><b>GitHub Copilot</b></summary>

npx skills add eduardo-sl/go-agent-skills -a copilot

Copilot auto-discovers skills from `.github/skills/`.

</details>

<details> <summary><b>Codex</b></summary>

npx skills add eduardo-sl/go-agent-skills -a codex

Codex auto-discovers skills from `~/.agents/skills/` and `.agents/skills/`.

</details>

<details> <summary><b>Windsurf · OpenCode · Cline</b></summary>

npx skills add eduardo-sl/go-agent-skills -a windsurf
npx skills add eduardo-sl/go-agent-skills -a opencode
npx skills add eduardo-sl/go-agent-skills -a cline

</details>

<details> <summary><b>Shell installer</b>: no Node required</summary>

git clone https://github.com/eduardo-sl/go-agent-skills.git
./go-agent-skills/scripts/install.sh /path/to/your-go-project --agent claude

# Preview without changing anything
./go-agent-skills/scripts/install.sh /path/to/project --agent claude --dry-run

# Symlink instead of copying, so a `git pull` updates every project
./go-agent-skills/scripts/install.sh /path/to/project --agent claude --symlink

Agents: `claude`, `cursor`, `copilot`, `codex`, `windsurf`. Add `--global` to install into your home directory.

</details>

<details> <summary><b>Manual copy</b></summary>

mkdir -p .claude/skills && cp -r go-agent-skills/skills/*/* .claude/skills/   # Claude Code
mkdir -p .cursor/skills && cp -r go-agent-skills/skills/*/* .cursor/skills/   # Cursor
mkdir -p .github/skills && cp -r go-agent-skills/skills/*/* .github/skills/   # Copilot
mkdir -p .agents/skills && cp -r go-agent-skills/skills/*/* .agents/skills/   # Codex / OpenCode

</details>

<details> <summary><b>Keeping them up to date</b></summary>

npx skills check      # anything out of date?
npx skills update     # bring them current
npx skills list       # what is installed
npx skills remove go-performance-review

</details>

---

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/marketplace.json · Manifest · 48 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": "eduardo-sl",
  3. "owner": { "name": "Eduardo Spinelli de Lima" },
  4. "metadata": { "description": "Skills for Go development" },
  5. "plugins": [
  6. {
  7. "name": "go-agent-skills",
  8. "source": ".",
  9. "skills": [
  10. "./skills/(code-quality)/go-coding-standards",
  11. "./skills/(code-quality)/go-code-review",
  12. "./skills/(code-quality)/go-error-handling",
  13. "./skills/(architecture)/go-architecture-review",
  14. "./skills/(architecture)/go-interface-design",
  15. "./skills/(architecture)/go-api-design",
  16. "./skills/(safety)/go-concurrency-review",
  17. "./skills/(safety)/go-security-audit",
  18. "./skills/(safety)/go-performance-review",
  19. "./skills/(testing)/go-test-quality",
  20. "./skills/(testing)/go-test-table-driven",
  21. "./skills/(workflow)/go-dependency-audit",
  22. "./skills/(workflow)/git-commit",
  23. "./skills/(code-quality)/go-context",
  24. "./skills/(code-quality)/go-modernize",
  25. "./skills/(data)/go-database",
  26. "./skills/(architecture)/go-design-patterns",
  27. "./skills/(safety)/go-observability",
  28. "./skills/(code-quality)/go-data-structures",
  29. "./skills/(code-quality)/go-documentation",
  30. "./skills/(architecture)/go-project-layout",
  31. "./skills/(architecture)/go-dependency-injection",
  32. "./skills/(architecture)/go-cli",
  33. "./skills/(architecture)/go-grpc",
  34. "./skills/(safety)/go-troubleshooting",
  35. "./skills/(workflow)/go-ci",
  36. "./skills/(workflow)/go-refactoring",
  37. "./skills/(workflow)/go-semantic-tools",
  38. "./skills/(safety)/go-defensive-coding",
  39. "./skills/(workflow)/go-binary-size",
  40. "./skills/(architecture)/go-openapi",
  41. "./skills/(architecture)/go-graphql",
  42. "./skills/(workflow)/go-skills-router",
  43. "./skills/(code-quality)/go-naming",
  44. "./skills/(workflow)/go-build-release"
  45. ]
  46. }
  47. ]
  48. }
README.md · README · 581 lines

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

  1. <p align="center">
  2. <img src="docs/assets/hero.png" alt="go-agent-skills — curated Go skills for AI coding agents" width="100%">
  3. </p>
  4. <p align="center">
  5. <a href="https://skills.sh/eduardo-sl/go-agent-skills"><img alt="skills" src="https://img.shields.io/badge/skills-35-00ADD8?style=for-the-badge&labelColor=06202B"></a>
  6. <a href="https://agentskills.io/specification.md"><img alt="spec" src="https://img.shields.io/badge/Agent%20Skills-spec%20compliant-7FE7C4?style=for-the-badge&labelColor=06202B"></a>
  7. <a href="https://github.com/eduardo-sl/go-agent-skills/actions/workflows/validate.yml"><img alt="ci" src="https://img.shields.io/github/actions/workflow/status/eduardo-sl/go-agent-skills/validate.yml?style=for-the-badge&labelColor=06202B&label=validate"></a>
  8. <a href="https://github.com/eduardo-sl/go-agent-skills/stargazers"><img alt="stars" src="https://img.shields.io/github/stars/eduardo-sl/go-agent-skills?style=for-the-badge&labelColor=06202B&color=F5C451"></a>
  9. <a href="LICENSE"><img alt="license" src="https://img.shields.io/badge/license-MIT-8FC7D8?style=for-the-badge&labelColor=06202B"></a>
  10. </p>
  11. <h3 align="center">Curated Go skills for AI coding agents.<br>Idiomatic by default, loaded only when they matter.</h3>
  12. <p align="center">
  13. <a href="#-quick-start">Quick start</a> ·
  14. <a href="#-usage">Usage</a> ·
  15. <a href="#-skills">Skills</a> ·
  16. <a href="#-how-it-works">How it works</a> ·
  17. <a href="#-evaluations">Evaluations</a> ·
  18. <a href="#-customizing">Customizing</a> ·
  19. <a href="#-faq">FAQ</a> ·
  20. <a href="#-contributing">Contributing</a>
  21. </p>
  22. ```bash
  23. npx skills add eduardo-sl/go-agent-skills
  24. ```
  25. ---
  26. ## Why
  27. AI coding agents write Go that compiles. Writing Go that reads like Go takes
  28. more than that. Left to defaults, an agent returns errors with no context,
  29. declares interfaces next to their only implementation, starts goroutines nothing
  30. ever stops, and reaches for `interface{}` where a type parameter belongs.
  31. **go-agent-skills** gives the agent the judgment an experienced Go reviewer
  32. brings: 35 focused skills grounded in [Effective Go](https://go.dev/doc/effective_go),
  33. [Go Code Review Comments](https://go.dev/wiki/CodeReviewComments), and patterns
  34. from large-scale production Go services. They follow the open
  35. [Agent Skills](https://agentskills.io/) standard, work in any compatible agent,
  36. and load **on demand**. Until a skill is relevant, it costs about 135 tokens.
  37. ```go
  38. // ❌ Before: the caller gets "sql: no rows in result set" and nothing else
  39. func (s *Service) User(id int) (*User, error) {
  40. u, err := s.repo.Find(id)
  41. if err != nil {
  42. return nil, err
  43. }
  44. return u, nil
  45. }
  46. // ✅ After (go-error-handling + go-context): cancellable, wrapped, still matchable
  47. func (s *Service) User(ctx context.Context, id int) (*User, error) {
  48. u, err := s.repo.Find(ctx, id)
  49. if err != nil {
  50. return nil, fmt.Errorf("find user %d: %w", id, err)
  51. }
  52. return u, nil
  53. }
  54. ```
  55. ### Highlights
  56. - 🎯 **35 skills across six areas.** Code quality, architecture, data, safety and performance, testing, and workflow.
  57. - 🪶 **Progressive disclosure.** About 4,800 tokens of descriptions at startup. Bodies and 62 reference files load only when a task needs them.
  58. - 🧭 **A router for overlap.** `go-skills-router` maps a task to the skill that owns it and draws the line where two overlap.
  59. - 🧪 **Measured, not asserted.** 159 eval cases you run with and without the skills. The difference between the two runs is the result.
  60. - 🔐 **Least privilege.** Every skill declares scoped `allowed-tools`. Review and audit skills cannot write.
  61. - 🔄 **Current with Go.** Covers Go 1.21 through 1.27. A weekly workflow opens an issue when a new Go release ships that `go-modernize` doesn't cover yet.
  62. - 🔌 **Agent-agnostic.** Works in Claude Code, Cursor, Codex, GitHub Copilot, Windsurf, OpenCode, Cline, and more.
  63. ---
  64. ## 🚀 Quick start
  65. Install with the [`npx skills`](https://skills.sh) CLI. It detects the agents you
  66. have and puts each skill where that agent looks for it. That covers **Claude Code**,
  67. **Cursor**, **Codex**, **GitHub Copilot**, **Windsurf**, **OpenCode**, **Cline**,
  68. and [37+ more agents](https://github.com/vercel-labs/skills#available-agents).
  69. ```bash
  70. # Everything, interactive
  71. npx skills add eduardo-sl/go-agent-skills
  72. # Look before you install
  73. npx skills add eduardo-sl/go-agent-skills --list
  74. # Only the skills you want
  75. npx skills add eduardo-sl/go-agent-skills --skill go-code-review --skill go-defensive-coding
  76. # Globally, for every project
  77. npx skills add eduardo-sl/go-agent-skills -g
  78. # Non-interactive, for CI and dotfiles
  79. npx skills add eduardo-sl/go-agent-skills --all -y
  80. ```
  81. <details>
  82. <summary><b>Claude Code</b>: plugin marketplace</summary>
  83. ```bash
  84. /plugin marketplace add eduardo-sl/go-agent-skills
  85. /plugin install go-agent-skills@eduardo-sl
  86. ```
  87. Or install the files directly: `npx skills add eduardo-sl/go-agent-skills -a claude-code`
  88. </details>
  89. <details>
  90. <summary><b>Cursor</b></summary>
  91. ```bash
  92. npx skills add eduardo-sl/go-agent-skills -a cursor
  93. ```
  94. Cursor auto-discovers skills from `.cursor/skills/` and `.agents/skills/`.
  95. </details>
  96. <details>
  97. <summary><b>GitHub Copilot</b></summary>
  98. ```bash
  99. npx skills add eduardo-sl/go-agent-skills -a copilot
  100. ```
  101. Copilot auto-discovers skills from `.github/skills/`.
  102. </details>
  103. <details>
  104. <summary><b>Codex</b></summary>
  105. ```bash
  106. npx skills add eduardo-sl/go-agent-skills -a codex
  107. ```
  108. Codex auto-discovers skills from `~/.agents/skills/` and `.agents/skills/`.
  109. </details>
  110. <details>
  111. <summary><b>Windsurf · OpenCode · Cline</b></summary>
  112. ```bash
  113. npx skills add eduardo-sl/go-agent-skills -a windsurf
  114. npx skills add eduardo-sl/go-agent-skills -a opencode
  115. npx skills add eduardo-sl/go-agent-skills -a cline
  116. ```
  117. </details>
  118. <details>
  119. <summary><b>Shell installer</b>: no Node required</summary>
  120. ```bash
  121. git clone https://github.com/eduardo-sl/go-agent-skills.git
  122. ./go-agent-skills/scripts/install.sh /path/to/your-go-project --agent claude
  123. # Preview without changing anything
  124. ./go-agent-skills/scripts/install.sh /path/to/project --agent claude --dry-run
  125. # Symlink instead of copying, so a `git pull` updates every project
  126. ./go-agent-skills/scripts/install.sh /path/to/project --agent claude --symlink
  127. ```
  128. Agents: `claude`, `cursor`, `copilot`, `codex`, `windsurf`. Add `--global` to
  129. install into your home directory.
  130. </details>
  131. <details>
  132. <summary><b>Manual copy</b></summary>
  133. ```bash
  134. mkdir -p .claude/skills && cp -r go-agent-skills/skills/*/* .claude/skills/ # Claude Code
  135. mkdir -p .cursor/skills && cp -r go-agent-skills/skills/*/* .cursor/skills/ # Cursor
  136. mkdir -p .github/skills && cp -r go-agent-skills/skills/*/* .github/skills/ # Copilot
  137. mkdir -p .agents/skills && cp -r go-agent-skills/skills/*/* .agents/skills/ # Codex / OpenCode
  138. ```
  139. </details>
  140. <details>
  141. <summary><b>Keeping them up to date</b></summary>
  142. ```bash
  143. npx skills check # anything out of date?
  144. npx skills update # bring them current
  145. npx skills list # what is installed
  146. npx skills remove go-performance-review
  147. ```
  148. </details>
  149. ---
  150. ## 💬 Usage
  151. There is nothing to learn. Work as usual, and the agent loads a skill when your
  152. task matches its description. Agents that support slash commands can also
  153. invoke a skill directly:
  154. ```text
  155. /go-code-review
  156. /go-concurrency-review
  157. ```
  158. Real tasks usually need more than one skill. These combinations come from
  159. [`go-skills-router`](skills/(workflow)/go-skills-router/):
  160. | Ask your agent | Skills it loads |
  161. | --- | --- |
  162. | "Review this PR" | `go-code-review` |
  163. | "Build a gRPC service with tests" | `go-grpc` + `go-test-quality` + `go-error-handling` |
  164. | "This endpoint is slow under load" | `go-troubleshooting` + `go-performance-review` + `go-database` |
  165. | "Harden this service before launch" | `go-security-audit` + `go-dependency-audit` + `go-defensive-coding` + `go-ci` |
  166. | "Split this monolith" | `go-architecture-review` + `go-refactoring` + `go-semantic-tools` |
  167. | "Scaffold a new CLI" | `go-project-layout` + `go-cli` + `go-ci` + `go-binary-size` |
  168. | "Migrate this to the current Go release" | `go-modernize` + `go-test-quality` + `go-ci` |
  169. > [!TIP]
  170. > To make a project use the skills on every Go task, ask your agent to
  171. > **"set up the Go skills for this repo"**. `go-skills-router` proposes a short
  172. > block for your `CLAUDE.md`, `AGENTS.md`, or Copilot/Cursor rules, and writes it
  173. > only after you approve the diff.
  174. ---
  175. ## 🧩 Skills
  176. ```text
  177. ┌──────────────────┐
  178. │ go-skills-router │ ← which skill owns this task?
  179. └─────────┬────────┘
  180. ┌────────────────────────────┼────────────────────────────┐
  181. ▼ ▼ ▼
  182. ┌─────────────────────────┐ ┌─────────────────────────┐ ┌─────────────────────────┐
  183. │ CODE QUALITY │ │ ARCHITECTURE │ │ SAFETY & PERFORMANCE │
  184. ├─────────────────────────┤ ├─────────────────────────┤ ├─────────────────────────┤
  185. │ go-coding-standards │ │ go-architecture-review │ │ go-concurrency-review │
  186. │ go-naming │ │ go-project-layout │ │ go-security-audit │
  187. │ go-code-review │ │ go-interface-design │ │ go-defensive-coding │
  188. │ go-error-handling │ │ go-api-design │ │ go-performance-review │
  189. │ go-context │ │ go-openapi │ │ go-observability │
  190. │ go-modernize │ │ go-graphql │ │ go-troubleshooting │
  191. │ go-data-structures │ │ go-grpc │ │ │
  192. │ go-documentation │ │ go-design-patterns │ │ │
  193. │ │ │ go-dependency-injection │ │ │
  194. │ │ │ go-cli │ │ │
  195. └─────────────────────────┘ └─────────────────────────┘ └─────────────────────────┘
  196. ┌─────────────────────────┐ ┌─────────────────────────┐ ┌─────────────────────────┐
  197. │ DATA │ │ TESTING │ │ WORKFLOW │
  198. ├─────────────────────────┤ ├─────────────────────────┤ ├─────────────────────────┤
  199. │ go-database │ │ go-test-quality │ │ go-dependency-audit │
  200. │ │ │ go-test-table-driven │ │ go-ci │
  201. │ │ │ │ │ go-refactoring │
  202. │ │ │ │ │ go-semantic-tools │
  203. │ │ │ │ │ go-binary-size │
  204. │ │ │ │ │ go-build-release │
  205. │ │ │ │ │ git-commit │
  206. └─────────────────────────┘ └─────────────────────────┘ └─────────────────────────┘
  207. ```
  208. **Reading the tables.** `Desc` is the description, loaded at startup for
  209. *every* skill. It is the text that decides whether a skill triggers. `SKILL.md`
  210. is what loads when the skill fires. `Tree` adds the `references/` files, which
  211. load only when the skill sends the agent to them. 📚 marks a skill that has
  212. reference files. Figures are approximate tokens (bytes ÷ 4).
  213. ### Code Quality
  214. | Skill | What it does | Triggers | Desc | SKILL.md | Tree |
  215. | --- | --- | --- | ---: | ---: | ---: |
  216. | [`go-code-review`](skills/(code-quality)/go-code-review/) | Structured review process with severity classification | "review this code", "check this PR" | 103 | 1,844 | 1,844 |
  217. | [`go-coding-standards`](skills/(code-quality)/go-coding-standards/) 📚 | Style conventions, imports, declarations, struct init, formatting | "check Go style", "fix formatting" | 136 | 1,812 | 2,694 |
  218. | [`go-context`](skills/(code-quality)/go-context/) 📚 | Context propagation, cancellation, timeouts, values | "context usage", "timeout", "context cancellation" | 108 | 2,054 | 3,751 |
  219. | [`go-data-structures`](skills/(code-quality)/go-data-structures/) 📚 | Slices, maps, sets, aliasing, preallocation, nil vs empty | "nil slice", "map iteration", "slice aliasing" | 135 | 2,031 | 2,747 |
  220. | [`go-documentation`](skills/(code-quality)/go-documentation/) 📚 | Godoc conventions, testable examples, deprecation notices | "add godoc", "document this package" | 108 | 1,743 | 2,327 |
  221. | [`go-error-handling`](skills/(code-quality)/go-error-handling/) 📚 | Error wrapping, sentinels, custom types, `errors.Is`/`As` | "handle errors", "error wrapping" | 131 | 2,053 | 2,678 |
  222. | [`go-modernize`](skills/(code-quality)/go-modernize/) 📚 | Generics, slog, errors.Join, slices/maps, range-over-func | "modernize", "use generics", "update Go" | 129 | 2,320 | 8,437 |
  223. | [`go-naming`](skills/(code-quality)/go-naming/) 📚 | Packages, stuttering, initialisms, getters, receivers, error names | "what should I name this", "naming review" | 136 | 2,044 | 2,991 |
  224. ### Architecture & Design
  225. | Skill | What it does | Triggers | Desc | SKILL.md | Tree |
  226. | --- | --- | --- | ---: | ---: | ---: |
  227. | [`go-api-design`](skills/(architecture)/go-api-design/) 📚 | REST/gRPC handlers, middleware, graceful shutdown, pagination | "design API", "HTTP handler" | 148 | 1,882 | 2,902 |
  228. | [`go-architecture-review`](skills/(architecture)/go-architecture-review/) 📚 | Package layout, dependency direction, layering, `internal/` | "review architecture", "project layout" | 130 | 2,134 | 2,664 |
  229. | [`go-cli`](skills/(architecture)/go-cli/) 📚 | Flags, subcommands, exit codes, signals, Cobra decision point | "build a CLI", "handle Ctrl+C", "exit codes" | 112 | 1,732 | 2,553 |
  230. | [`go-dependency-injection`](skills/(architecture)/go-dependency-injection/) | Constructor injection, composition root, wire/fx trade-offs | "dependency injection", "remove global state" | 115 | 1,563 | 1,563 |
  231. | [`go-design-patterns`](skills/(architecture)/go-design-patterns/) 📚 | Functional options, factory, strategy, middleware/decorator | "design pattern", "functional options" | 118 | 1,981 | 5,083 |
  232. | [`go-graphql`](skills/(architecture)/go-graphql/) 📚 | gqlgen schema-first, resolvers, dataloaders, complexity limits, field auth | "GraphQL", "gqlgen", "N+1 queries", "dataloader" | 155 | 2,108 | 2,572 |
  233. | [`go-grpc`](skills/(architecture)/go-grpc/) 📚 | Proto design, status codes, interceptors, deadlines, streaming | "gRPC service", "interceptor", "proto design" | 114 | 2,228 | 3,403 |
  234. | [`go-interface-design`](skills/(architecture)/go-interface-design/) 📚 | Consumer-side interfaces, composition, compliance checks | "design interface", "accept interfaces" | 143 | 2,124 | 2,679 |
  235. | [`go-openapi`](skills/(architecture)/go-openapi/) | Spec-first REST with oapi-codegen, validation middleware, oasdiff, contract tests | "OpenAPI", "oapi-codegen", "generate a client from the spec" | 174 | 2,051 | 2,051 |
  236. | [`go-project-layout`](skills/(architecture)/go-project-layout/) | Scaffolding new projects: cmd/internal, module naming, thin main | "new Go project", "scaffold a service" | 114 | 1,868 | 1,868 |
  237. ### Data
  238. | Skill | What it does | Triggers | Desc | SKILL.md | Tree |
  239. | --- | --- | --- | ---: | ---: | ---: |
  240. | [`go-database`](skills/(data)/go-database/) 📚 | Connection pools, transactions, sqlc, migrations, repository pattern | "database access", "SQL query", "transactions" | 113 | 2,079 | 5,480 |
  241. ### Safety & Performance
  242. | Skill | What it does | Triggers | Desc | SKILL.md | Tree |
  243. | --- | --- | --- | ---: | ---: | ---: |
  244. | [`go-concurrency-review`](skills/(safety)/go-concurrency-review/) 📚 | Goroutine lifecycle, channels, mutexes, race detection | "check thread safety", "goroutine leak" | 140 | 2,242 | 4,521 |
  245. | [`go-defensive-coding`](skills/(safety)/go-defensive-coding/) 📚 | Typed-nil interfaces, slice aliasing, integer overflow, defensive copying | "nil pointer panic", "integer overflow", "defensive copy" | 186 | 2,379 | 5,659 |
  246. | [`go-observability`](skills/(safety)/go-observability/) 📚 | Structured logging (slog), tracing, metrics, OpenTelemetry | "add logging", "tracing", "metrics" | 109 | 2,006 | 5,342 |
  247. | [`go-performance-review`](skills/(safety)/go-performance-review/) 📚 | Allocations, benchmarking, pprof, hot path optimization | "check performance", "reduce allocations" | 134 | 2,390 | 7,184 |
  248. | [`go-security-audit`](skills/(safety)/go-security-audit/) 📚 | OWASP, SQL injection, auth, secrets, input validation | "security review", "check vulnerabilities" | 137 | 2,585 | 7,301 |
  249. | [`go-troubleshooting`](skills/(safety)/go-troubleshooting/) 📚 | Panics, deadlocks, memory/goroutine leaks, pprof diffing, delve | "debug this panic", "memory leak", "deadlock" | 127 | 2,487 | 4,844 |
  250. ### Testing
  251. | Skill | What it does | Triggers | Desc | SKILL.md | Tree |
  252. | --- | --- | --- | ---: | ---: | ---: |
  253. | [`go-test-quality`](skills/(testing)/go-test-quality/) 📚 | Test philosophy, subtests, httptest, golden files, fuzz, testcontainers | "add tests", "improve coverage" | 186 | 2,654 | 5,570 |
  254. | [`go-test-table-driven`](skills/(testing)/go-test-table-driven/) 📚 | Deep dive on table-driven tests: when to use, struct design, refactoring | "table-driven test", "test matrix" | 162 | 1,647 | 4,387 |
  255. ### Workflow
  256. | Skill | What it does | Triggers | Desc | SKILL.md | Tree |
  257. | --- | --- | --- | ---: | ---: | ---: |
  258. | [`git-commit`](skills/(workflow)/git-commit/) | Conventional Commits, atomic commits, pre-commit verification | "commit changes", "commit message" | 109 | 1,466 | 1,466 |
  259. | [`go-binary-size`](skills/(workflow)/go-binary-size/) | Linker flags, inlining, CGO, build tags, embedded assets, image size | "binary is too big", "shrink the binary", "reduce image size" | 166 | 1,912 | 1,912 |
  260. | [`go-build-release`](skills/(workflow)/go-build-release/) 📚 | Reproducible builds, GoReleaser, SBOMs, cosign signing, provenance, images | "release a Go binary", "set up GoReleaser", "sign the release" | 156 | 1,734 | 3,358 |
  261. | [`go-ci`](skills/(workflow)/go-ci/) 📚 | GitHub Actions, golangci-lint, coverage gates, Makefile parity | "set up CI", "add lint to pipeline" | 149 | 1,972 | 3,150 |
  262. | [`go-dependency-audit`](skills/(workflow)/go-dependency-audit/) 📚 | Module hygiene, `govulncheck`, dep evaluation, go.mod review | "check dependencies", "audit deps" | 136 | 1,843 | 2,356 |
  263. | [`go-refactoring`](skills/(workflow)/go-refactoring/) 📚 | Behavior-preserving steps, extract package, strangler migrations | "refactor this", "break circular dependency" | 142 | 1,958 | 2,563 |
  264. | [`go-semantic-tools`](skills/(workflow)/go-semantic-tools/) 📚 | gopls navigation, go list dependency graphs, semantic rename | "find all callers", "who implements this" | 155 | 1,727 | 2,507 |
  265. | [`go-skills-router`](skills/(workflow)/go-skills-router/) | Routes a task to the skill that owns it, plus the secondary skills to load | "which skill should I use", "what Go skills do you have" | 175 | 2,657 | 2,657 |
  266. ---
  267. ## 🧠 How it works
  268. Each skill loads in three tiers, and each tier is paid for only when it is needed:
  269. ```text
  270. always loaded when a task matches when the skill points there
  271. ┌──────────────────┐ ┌──────────────────────┐ ┌────────────────────────┐
  272. │ description │ ─────▶ │ SKILL.md │ ─────▶ │ references/*.md │
  273. │ what it covers, │ │ procedure, good/bad │ │ edge cases, recipes, │
  274. │ when NOT to fire │ │ pairs, checklist │ │ migrations │
  275. └──────────────────┘ └──────────────────────┘ └────────────────────────┘
  276. ~135 tokens each ~2,000 tokens each never all at once
  277. ~4,800 for all 35 2–4 per typical task ~125,000 in the full tree
  278. ```
  279. The descriptions are the only cost paid on every request, Go work or not. A
  280. typical task fires two to four skills. The full tree is about 26 times the
  281. startup cost and is never loaded at once. That gap is the point of
  282. progressive disclosure.
  283. ---
  284. ## 🧪 Evaluations
  285. A skill that doesn't change the output costs context for nothing.
  286. [`evals/`](evals/) is the harness that tells the difference: 159 cases, each a
  287. realistic prompt with regex assertions and optional rubric checks graded by a
  288. second model.
  289. ```bash
  290. # In a project with the skills installed
  291. scripts/run-evals.py --cmd 'claude -p "{prompt}"' --label with-skills
  292. # In one without them
  293. scripts/run-evals.py --cmd 'claude -p "{prompt}"' --label baseline
  294. ```
  295. The delta is the measurement. `--cmd` takes any agent CLI, so the same suite
  296. runs against whatever agent you use.
  297. One suite measures something different. `go-skills-router` asserts *which
  298. skill* a task should route to. With 35 skills whose triggers overlap, routing
  299. to the wrong one costs more than any description does. The case format is
  300. documented in [`evals/README.md`](evals/README.md).
  301. > [!NOTE]
  302. > No scores are published here. Results depend on the model, its version, and
  303. > the day you run them, and a score without those three recorded tells you
  304. > nothing. Run the suite against your own agent and judge for yourself.
  305. ---
  306. ## 🔐 Security
  307. Skills are prompts injected into an agent that already has shell and file-write
  308. access. This repository treats them as security-sensitive:
  309. - **Least-privilege tools.** Every skill declares `allowed-tools`. Review and
  310. audit skills cannot write, and every `Bash(...)` grant is scoped to one binary.
  311. - **No remote code.** No skill fetches remote content or runs downloaded code.
  312. The only external hosts referenced anywhere in `skills/` are `github.com` and
  313. `localhost`.
  314. - **Enforced in CI.** `scripts/validate.sh` rejects unscoped `Bash`, any skill
  315. that declares itself read-only but asks for `Write`, and any instruction that
  316. pipes a download into a shell.
  317. - **Scanned on publish.** [skills.sh](https://www.skills.sh/eduardo-sl/go-agent-skills)
  318. scans every published skill with Socket, Snyk, and Gen Agent Trust Hub.
  319. The threat model and private disclosure process are in [SECURITY.md](SECURITY.md).
  320. ---
  321. ## 🎚 Customizing
  322. **Your team's conventions win.** The convention skills (`go-coding-standards`,
  323. `go-error-handling`, `go-test-quality`, `go-api-design`, `go-database`,
  324. `git-commit`, and others) are marked as community defaults. To override one
  325. without forking, write a short team skill, or a rule in `CLAUDE.md` or
  326. `AGENTS.md`, that names the skill it supersedes:
  327. ```markdown
  328. This skill supersedes `go-coding-standards` for Acme projects.
  329. ```
  330. Where the two disagree, the agent follows yours. For deeper changes, fork the
  331. repository and install from your fork with
  332. `npx skills add your-org/go-agent-skills`.
  333. **Fixing triggers.** If a skill fires too often, or doesn't fire when it should,
  334. the fix is its `description` field, because that field is the entire triggering
  335. mechanism. [Open an issue](https://github.com/eduardo-sl/go-agent-skills/issues)
  336. with the prompt that misrouted and the skill you expected. Small wording changes
  337. have a large effect on trigger accuracy.
  338. ---
  339. ## 🎯 Design principles
  340. - **Written for agents, not readers.** Imperative steps, ✅/❌ contrast pairs,
  341. and a verification checklist at the end of every skill. Agents learn from
  342. contrast, not prose.
  343. - **Negative triggers earn their keep.** Every description says what the skill
  344. does *not* cover and names the skill that does. Loading the wrong skill costs
  345. more than loading none.
  346. - **Verification is executable.** Where a tool can prove a rule (`go vet`,
  347. `golangci-lint`, `govulncheck`, `go test -race`), the skill runs that tool
  348. instead of asking the agent to judge.
  349. - **Small by default.** `SKILL.md` stays within 250 lines. CI warns above that
  350. and fails above 500. Depth goes in `references/`.
  351. - **Self-contained.** No skill requires another to be loaded first. Skills name
  352. each other only as pointers. `go-skills-router` is the one index, and it is
  353. optional too.
  354. ---
  355. ## 🧱 Repository structure
  356. ```text
  357. go-agent-skills/
  358. ├── skills/(category)/skill-name/
  359. │ ├── SKILL.md # ≤250 lines: procedure, patterns, checklist
  360. │ └── references/ # depth, loaded only when SKILL.md says so
  361. ├── evals/
  362. │ ├── README.md # how to measure a skill's worth
  363. │ └── cases/ # one prompt + assertion suite per skill
  364. ├── scripts/
  365. │ ├── install.sh # shell installer (--dry-run, --symlink)
  366. │ ├── run-evals.py # drives any agent CLI
  367. │ ├── validate.sh # format, frontmatter, tools, catalogue sync
  368. │ └── check-go-release.sh # flags Go releases go-modernize doesn't cover
  369. ├── docs/
  370. │ ├── SKILL_GUIDELINES.md # quality bar for authoring
  371. │ └── skill-gap-analysis.md # what exists, what was rejected, and why
  372. │
  373. │ # platform discovery files: all must list the same skills
  374. ├── AGENTS.md · CLAUDE.md · .claude-plugin/marketplace.json
  375. ├── .cursor/rules/ · .windsurf/rules/ · .clinerules · .github/copilot-instructions.md
  376. └── .opencode/config.json
  377. ```
  378. ---
  379. ## ❓ FAQ
  380. <details>
  381. <summary><b>Do the skills cost anything when I'm not writing Go?</b></summary>
  382. Only the descriptions, about 4,800 tokens for all 35. Skill bodies load only
  383. when a task matches. To cut that further, install only the skills you use
  384. (`--skill`) or install per project instead of globally.
  385. </details>
  386. <details>
  387. <summary><b>Do I need all 35?</b></summary>
  388. No. Every skill is self-contained and works alone. A good starting set is
  389. `go-code-review`, `go-error-handling`, `go-concurrency-review`, and
  390. `go-test-quality`. Add more as your tasks need them.
  391. </details>
  392. <details>
  393. <summary><b>Which Go versions are covered?</b></summary>
  394. Go 1.21 through 1.27. Advice that depends on a release is labeled with it
  395. (for example, `sync.WaitGroup.Go`, *Go 1.25+*), so the agent checks `go.mod`
  396. before suggesting it. A weekly workflow opens an issue when a new Go release
  397. ships that `go-modernize` doesn't cover yet.
  398. </details>
  399. <details>
  400. <summary><b>Is this only for Claude Code?</b></summary>
  401. No. The skills follow the open [Agent Skills](https://agentskills.io/) standard
  402. and contain no agent-specific instructions. The repository also ships discovery
  403. files for Cursor, Copilot, Windsurf, Cline, and OpenCode, and CI checks that they
  404. list every skill.
  405. </details>
  406. <details>
  407. <summary><b>Can a skill run commands on my machine?</b></summary>
  408. A skill runs nothing by itself. It steers your agent, and it declares the tools it
  409. needs in `allowed-tools`. Some agents pre-approve those tools while the skill is
  410. active, so the grants are kept narrow. Review and audit skills are read-only, and
  411. every `Bash` grant is scoped to a single binary such as `go` or `gofmt`. See
  412. [Security](#-security).
  413. </details>
  414. ---
  415. ## 🤝 Contributing
  416. Contributions are welcome. The skills are loaded into agents that real
  417. engineers use on real codebases, so a small, correct contribution is worth more
  418. than a large one. Good places to start:
  419. - **A misrouted prompt.** Open an issue with what you typed and the skill you expected.
  420. - **An eval case.** Add a case that fails without the skill and passes with it.
  421. - **A factual fix.** Wrong API, outdated Go version, or an example that doesn't compile.
  422. - **A new skill.** Check [`docs/skill-gap-analysis.md`](docs/skill-gap-analysis.md) first. It lists what has been considered and why.
  423. The budget for each skill:
  424. | | Target |
  425. | --- | --- |
  426. | `description` | ~100–200 tokens: what it does, when to fire, when *not* to |
  427. | `SKILL.md` | ≤250 lines, ~1,000–2,000 tokens: procedure and patterns, nothing else |
  428. | `references/*.md` | Whatever depth needs, loaded on demand |
  429. | Full tree | Under ~10,000 tokens |
  430. Every PR must pass `./scripts/validate.sh` and ship at least one eval case that
  431. fails without the skill. Read [CONTRIBUTING.md](CONTRIBUTING.md) and
  432. [docs/SKILL_GUIDELINES.md](docs/SKILL_GUIDELINES.md) before opening one.
  433. ---
  434. ## 🙏 Acknowledgements
  435. - [Effective Go](https://go.dev/doc/effective_go): the Go team's guide to idiomatic Go
  436. - [Go Code Review Comments](https://go.dev/wiki/CodeReviewComments): the community's review standards
  437. - [Uber Go Style Guide](https://github.com/uber-go/guide/blob/master/style.md): cited where a convention comes from it
  438. - [Agent Skills](https://agentskills.io/): the open skill specification
  439. - [Vercel Skills CLI](https://github.com/vercel-labs/skills): the `npx skills` distribution ecosystem
  440. - [Anthropic Skills](https://github.com/anthropics/skills): patterns for production-grade skills
  441. The Go gopher was designed by [Renée French](https://reneefrench.blogspot.com/)
  442. and is licensed under [CC BY 3.0](https://creativecommons.org/licenses/by/3.0/).
  443. The banner above is an original drawing in that spirit.
  444. If these skills save you a review cycle, a ⭐ helps other Go developers find them.
  445. ## 📝 License
  446. [MIT](LICENSE) © [Eduardo Spinelli de Lima](https://github.com/eduardo-sl)

Ratings and comments

Sign in to rate this skill.

Sign in

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