Guide · Agent skill
How to use the golang-testing agent skill for Go tests
Updated · written with AI from the project's own documentation and checked against our catalogue data
The golang-testing skill is a written guide, in Spanish, that teaches an AI agent how to write Go tests the way the source describes: test-first (RED-GREEN-REFACTOR), table-driven tests, subtests, helpers, temporary files, golden files and interface-based mocks. This page explains what the skill changes, how to install it, how to ask for it in plain language and what to check before relying on it. You do not need prior experience with agent skills to follow it.
Go Testing Patternsaffaan-m/ECC · MIT Download the skill Quick start
- 1Get the skill files. Download the golang-testing ZIP from the directory page. It contains SKILL.md.
- 2Unzip into a skills folder. Unzip it into ~/.claude/skills/ for all projects, or into .claude/skills/ inside one project.
- 3Or upload in the Claude apps. In the Claude apps, go to Settings → Capabilities → Skills and upload the skill.
- 4Check the Go toolchain. Make sure the go command is installed, since the skill's examples use go test.
- 5Ask for a test in plain language. Describe the Go function and the cases you want tested, and mention tests or TDD.
- 6Run go test. Run go test in the package folder to see failures and passes.
- 7Review before committing. Read the generated tests and any golden file changes before you keep them.
What the golang-testing skill makes the agent do
A skill is a folder with a SKILL.md file that an AI agent reads when a task matches the skill's description. The golang-testing skill is for writing and improving Go code and its tests. Its source says it applies when you write new Go functions or methods, add coverage to existing code, create benchmarks for performance-critical code, add fuzz tests for input validation, or follow a TDD workflow in a Go project.
The skill does not add any tool or program. It only gives the agent a set of conventions to follow, so the agent's output is shaped by these examples.
- Test-first workflow: write a failing test, make it pass with minimal code, then refactor while the tests stay green.
- Table-driven tests with named cases, including error cases.
- Grouped subtests with t.Run and parallel subtests with t.Parallel.
- Helper functions that use t.Helper, t.Cleanup and t.TempDir.
- Golden files stored in testdata/ and an -update flag to refresh them.
- Interface-based mocking examples.
Install the golang-testing skill
Download the ZIP of the skill from the directory page. Unzip it so that the skill folder, containing SKILL.md, ends up in one of these places: ~/.claude/skills/ to make it available in all your projects, or .claude/skills/ inside a specific project to make it available only there.
If you use the Claude apps instead, upload the skill under Settings → Capabilities → Skills.
- Personal install: ~/.claude/skills/
- Project install: .claude/skills/ in the project folder
- Claude apps: Settings → Capabilities → Skills, then upload the skill
Trigger the skill with natural requests
You do not need a special command. Describe the Go task in plain language and mention tests. The agent decides to use the skill when your request matches its description, which covers new functions, coverage, benchmarks, fuzzing and TDD.
Be specific about the function and the behaviour you want. The more clearly you name the function, its inputs and the error cases, the more useful the table-driven tests will be.
- Write a TDD-style test for a function ParseDate that returns an error on an empty string.
- Add table-driven tests for Add that cover negative numbers and zero.
- Improve test coverage for the user repository package.
- Create a benchmark for the JSON parser in this package.
- Add a fuzz test for the input validator.
Run the tests and use golden files
The examples are run with the standard Go test command. The source shows go test printing FAIL during the RED step and PASS after the code is implemented.
For golden files, the source keeps expected output in testdata/ as .golden files and defines a test flag named update. Running the test with that flag rewrites the golden files, so review the changed output before you commit it.
go testWhat the skill needs and the safety notes
The skill requires the Go toolchain, because the examples use the go test command and Go's testing package. According to the source, some examples use a SQLite driver (sqlite3) if you copy the database helper. Without that driver, the database helper will not compile.
Per the listing, the skill runs no scripts and uses no network access. It is only a set of instructions and examples. Check any generated code before running it, as you would with any code an agent writes.
- Requires: Go toolchain (the go test command)
- Optional: a sqlite3 driver if you use the database helper example
- Runs scripts: no
- Uses network: no
Tips for getting good results
The examples are generic. If your team has its own testing standards, tell the agent to follow your project's conventions, or the agent may apply these examples in place of your house style. Review the test names and error checks it produces, since the source's examples use simple assertions.
Use the TDD flow when you want to design behaviour first. Ask for the failing test, check that it fails for the right reason, and only then ask for the implementation.
- State your house testing rules in the request or in the project's own instructions.
- Ask for the RED step first if you want to review the expected behaviour.
- Keep tests in the same package as the code unless you have a reason not to.
- Review golden file changes before committing them.
What people use it for
- Writing table-driven tests for a small Go utility function with several input cases.
- Adding grouped subtests to a service method that needs setup and teardown.
- Building a test-first workflow where the agent writes the failing test before the implementation.
- Creating golden file tests for a template or renderer whose output should not change unexpectedly.
- Learning how table-driven tests and subtests are structured by reading the agent's output.
Frequently asked questions
Is the golang-testing skill free?
The listing says the skill is released under the MIT licence. The source describes it as a Spanish-language written guide and does not mention any price, so check the directory page for current terms.
What do I need to use the golang-testing skill?
You need the Go toolchain so the go test command works. If you copy the database helper example, you also need a sqlite3 driver. The skill runs no scripts and uses no network.
Where do I install an agent skill like this one?
Unzip the skill folder into ~/.claude/skills/ for personal use or .claude/skills/ inside a project. In the Claude apps, upload it under Settings → Capabilities → Skills.
Does the skill run code or access the internet?
According to the listing, it runs no scripts and uses no network. It contains a SKILL.md file with written guidance and examples that the agent follows.
Is it better than writing tests without a guide?
It is useful when you want consistent, idiomatic Go tests from an agent. It is less suitable if your team already has its own testing standards, because the agent may follow these generic examples instead.
Why does my agent ignore the skill or write different tests?
The skill is triggered by matching your request to its description, so mention Go and tests explicitly. If your project has its own conventions, the agent may not follow this guide, so state your rules in the request.
New agent skills, repos and AI tools — every week
The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.
Our verdict
Use this skill if you write Go and want an AI agent to produce consistent, table-driven, test-first code with the standard testing package. Pick something else if your project is not in Go or if your team already has detailed testing standards that these generic examples could override.
Download the skill