New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Go Development Guidelines

by jumppad-labs in jumppad-labs/jumppad

Sets idiomatic Go conventions with a test-first workflow, using testify/require for assertions and mockery for mocks, for new features, packages and refactors.

MPL-2.0Auto-check passedDevelopment

Install Go Development Guidelines

skills CLI
$ npx skills add jumppad-labs/jumppad --skill go-dev-guidelines -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install jumppad-labs/jumppad go-dev-guidelines --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/jumppad-labs/jumppad.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/go-dev-guidelines .claude/skills/go-dev-guidelines && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
go-dev-guidelines
GitHub stars
263
Token cost
~1.5k tokens
SKILL.md length
510 words
Files
8 (incl. references)
Skills in repo
8
Repo updated
First seen
Licence
MPL-2.0

At a glance

Sets idiomatic Go conventions with a test-first workflow, using testify/require for assertions and mockery for mocks, for new features, packages and refactors.

  • Works in 8 steps: Follow Test-Driven Development (TDD) → Use testify/require for Unit Tests → Use Mockery for Mocks → …
  • Writing a new Go feature test-first
  • SKILL.md covers Overview, Quick Start Checklists, Core Principles and Standard Go Directory Structure, plus 3 more sections
  • Calls go

What it does

The skill gives two checklists, one for adding a feature to an existing Go project and one for starting a new service or package. Feature work runs from a small interface through tests, mockery-generated mocks and the implementation, then explicit error handling, integration tests, go vet and gofmt, and godoc comments. New packages follow the standard /cmd, /internal and /pkg layout with dependency injection, structured logging and graceful shutdown.

Testing rules are specific: assertions use github.com/stretchr/testify/require, mocks live in a mocks subfolder beside the interface, table-driven tests are avoided in favor of one explicit function per scenario, and success and failure cases stay in separate functions. Reference files cover code organization, concurrency patterns, dependencies, error handling, naming conventions, a testing guide and complete examples.

When your agent uses it

  • Writing a new Go feature test-first
  • Setting up the layout of a new Go service or package
  • Generating mockery mocks and writing testify/require tests
  • Refactoring Go code to follow naming and error-handling conventions

Example prompts

  • “Add a retry wrapper to the HTTP client package, tests first, with a mockery mock for its interface.”
  • “Create a new Go service for ingesting webhooks using the standard cmd and internal layout.”
  • “Rewrite my table-driven tests as separate explicit test functions.”

Requirements

  • A Go toolchain with testify and mockery available

Workflow steps

8 steps, taken from the step headings in SKILL.md.

  1. Follow Test-Driven Development (TDD)
  2. Use testify/require for Unit Tests
  3. Use Mockery for Mocks
  4. Never Use Table-Driven Tests
  5. Never Mix Positive and Negative Tests
  6. Handle All Errors Explicitly
  7. Prefer Small, Focused Interfaces
  8. Use any Instead of interface{}

What it can do on your machine

Read from SKILL.md and the folder at commit 34289ff. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • go

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Go Development Guidelines loads about 1.5k tokens when it runs, and up to ~28k if it reads all its reference files. Until then it costs about 91 tokens; SKILL.md has 510 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~91
When it runs · the whole SKILL.md, loaded when a task matches
~1.5k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~28k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from jumppad-labs/jumppad at commit 34289ff, republished under its MPL-2.0 licence (© jumppad-labs). 510 words, ~1,540 tokens.

Download SKILL.mdSave it as .claude/skills/go-dev-guidelines/SKILL.md (or your agent's skills folder). This skill also uses 7 other files; get the full folder from GitHub.
name
go-dev-guidelines
description
This skill should be used when writing, refactoring, or testing Go code. It provides idiomatic Go development patterns, TDD-based workflows, project structure conventions, and testing best practices using testify/require and mockery. Activate this skill when creating new Go features, services, packages, tests, or when setting up new Go projects.

Go Development Guidelines

Overview

This skill provides comprehensive guidelines for idiomatic Go development with a Test-Driven Development (TDD) approach. Follow these patterns when writing Go code, creating tests, organizing projects, or refactoring existing code.

Quick Start Checklists

New Go Feature Checklist

When implementing a new feature in an existing Go project:

  1. Define interface - Create small, focused interface in appropriate package
  2. Write tests first - Create *_test.go file with testify/require tests
  3. Generate mocks - Use mockery to generate mocks in mocks/ subfolder
  4. Implement logic - Write the implementation to satisfy tests
  5. Handle errors - Ensure all errors are explicitly handled
  6. Add integration tests - Test the feature end-to-end if applicable
  7. Run go vet & gofmt - Ensure code meets Go standards
  8. Update documentation - Add godoc comments for exported types/functions
New Go Service/Package Checklist

When creating a new Go service or package from scratch:

  1. Setup project structure - Use standard Go layout (/cmd, /internal, /pkg)
  2. Initialize module - Run go mod init with appropriate module path
  3. Define core interfaces - Start with small, focused interfaces
  4. Write tests first - Follow TDD approach for all business logic
  5. Implement with DI - Use dependency injection for testability
  6. Add logging - Include structured logging for observability
  7. Configure graceful shutdown - Implement proper cleanup for services
  8. Document package - Add package-level godoc and README

Core Principles

Follow these seven core principles for all Go development:

1. Follow Test-Driven Development (TDD)

Write tests before implementation. Tests should be easy to read and favor verbosity over abstraction.

2. Use testify/require for Unit Tests

All unit tests must use github.com/stretchr/testify/require for assertions.

3. Use Mockery for Mocks

Generate mocks using mockery. Mocks must be localized in a mocks/ subfolder next to the interface being mocked.

4. Never Use Table-Driven Tests

Avoid table-driven tests. Write explicit test functions for each scenario.

Show full SKILL.md (208 more words)Show less
5. Never Mix Positive and Negative Tests

Keep positive (success) and negative (error) test cases in separate test functions.

6. Handle All Errors Explicitly

Never ignore errors. Always handle them explicitly or return them to the caller.

7. Prefer Small, Focused Interfaces

Design interfaces with few methods. Use composition over large interfaces.

8. Use any Instead of interface{}

For generic types, prefer any over interface{} (Go 1.18+).

Standard Go Directory Structure

project-root/
├── cmd/                  # Main applications
│   └── myapp/
│       └── main.go
├── internal/             # Private application code
│   ├── handler/          # HTTP handlers
│   │   ├── handler.go
│   │   ├── handler_test.go
│   │   └── mocks/        # Mocks for handler interfaces
│   ├── service/          # Business logic
│   │   ├── service.go
│   │   ├── service_test.go
│   │   └── mocks/
│   └── repository/       # Data access
│       ├── repository.go
│       ├── repository_test.go
│       └── mocks/
├── pkg/                  # Public library code
│   └── client/
│       ├── client.go
│       ├── client_test.go
│       └── mocks/
├── api/                  # API definitions (OpenAPI, protobuf)
├── configs/              # Configuration files
├── go.mod
├── go.sum
└── README.md

Quick Reference

Common Test Patterns
go
// Unit test with mock
func TestServiceCreate(t *testing.T) {
    mockRepo := mocks.NewRepository(t)
    mockRepo.On("Save", mock.Anything).Return(nil)

    svc := NewService(mockRepo)
    err := svc.Create(context.Background(), data)

    require.NoError(t, err)
    mockRepo.AssertExpectations(t)
}

// Separate negative test
func TestServiceCreate_RepoError(t *testing.T) {
    mockRepo := mocks.NewRepository(t)
    mockRepo.On("Save", mock.Anything).Return(errors.New("db error"))

    svc := NewService(mockRepo)
    err := svc.Create(context.Background(), data)

    require.Error(t, err)
    require.Contains(t, err.Error(), "db error")
}
Naming Conventions
  • Packages: Short, lowercase, no underscores (handler, service)
  • Files: Lowercase with underscores (user_service.go, user_service_test.go)
  • Types: PascalCase (UserService, HTTPHandler)
  • Functions/Methods: PascalCase for exported, camelCase for unexported
  • Interfaces: Often end with -er suffix (Reader, Writer, UserRepository)

Navigation Table

Use this table to find detailed guidance for specific tasks:

If You Need To...See This Resource
Set up a new Go project structureProject Structure
Understand Go naming conventionsNaming Conventions
Write tests with TDD, testify/require, and mockeryTesting Guide
Organize packages, interfaces, and dependenciesCode Organization
Handle errors idiomaticallyError Handling
Work with goroutines, channels, and contextConcurrency Patterns
Manage dependencies and go.modDependencies
See complete working examplesComplete Examples

Resources

This skill includes detailed reference documentation in the references/ directory. Claude will load these resources as needed when working on specific tasks.

© jumppad-labs, MPL-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 7 other files (references) in .claude/skills/go-dev-guidelines of jumppad-labs/jumppad.

  • SKILL.md
  • references/code-organization.md
  • references/complete-examples.md
  • references/concurrency-patterns.md
  • references/dependencies.md
  • references/error-handling.md
  • references/naming-conventions.md
  • references/testing-guide.md

Open the folder on GitHubat commit 34289ff

Compare with similar skills

Go Development Guidelines next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Go Development Guidelines compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Go Development Guidelines this skilljumppad-labs/jumppad263—~1.5kAutomated safety check: PassMPL-2.0
Strict Programming Practicescode-yeongyu/oh-my-openagent70k—~9.5kAutomated safety check: PassCustom licence
Clean Codejd-solanki/slidev-theme-dracula1611 repos~3.8kAutomated safety check: PassMIT
Go Guidelinesmhmtszr/go-guidelines104—~885Automated safety check: WarnMIT
Agent Implementer Sparc Coderruvnet/ruflo74k2 repos~1.6kAutomated safety check: PassMIT
Azure Cosmos DB Pyaiskillstore/marketplace4304 repos~2.1kAutomated safety check: PassNone

Similar skills

  • Strict Programming Practices

    code-yeongyu/oh-my-openagent

    Applies strict, type-first coding rules for Python, Rust, TypeScript and Go, loading the matching language reference before the agent writes or edits any code.

    70k GitHub stars~9.5k tokensUpdated today
    DevelopmentAuto-check passed

  • Clean Code

    jd-solanki/slidev-theme-dracula

    Write readable, maintainable code through disciplined naming, small functions, and clean error handling.

    161 GitHub starsUsed in 1 repo~3.8k tokens
    DevelopmentAuto-check passed

  • Go Guidelines

    mhmtszr/go-guidelines

    Applies version-aware Go guidance when writing or reviewing Go code, loading only the reference files that match the task, from syntax and performance to concurrency and testing.

    104 GitHub stars~885 tokensUpdated 1 mo ago
    DevelopmentAuto-check: warnings

  • Agent Implementer Sparc Coder

    ruvnet/ruflo

    Agent skill for implementer-sparc-coder - invoke with $agent-implementer-sparc-coder

    74k GitHub starsUsed in 2 repos~1.6k tokens
    DevelopmentAuto-check passed

  • Azure Cosmos DB Py

    aiskillstore/marketplace

    Build production-grade Azure Cosmos DB NoSQL services following clean code, security best practices, and TDD principles.

    430 GitHub starsUsed in 4 repos~2.1k tokens
    DevelopmentAuto-check passed

  • Python

    alinaqi/maggy

    Python development with ruff, mypy, pytest - TDD and type safety

    707 GitHub stars~1.1k tokensUpdated 15 days ago
    DevelopmentAuto-check passed

More from jumppad-labs/jumppad

All 8 skills in this repo

  • GitHub Issue Reader

    jumppad-labs/jumppad

    Pulls a GitHub issue's description, comments, labels, assignees, milestone and linked pull requests into one markdown report so the agent can plan a fix.

    263 GitHub stars~958 tokensUpdated 7 days ago
    Auto-check passed

  • Spektacular Plan Implementation

    jumppad-labs/jumppad

    Executes an approved plan step by step through the spektacular CLI, which acts as the state machine, producing code, tests and a changelog.

    263 GitHub stars~1.8k tokensUpdated 7 days ago
    Auto-check passed

  • Interactive Implementation Planner

    jumppad-labs/jumppad

    Builds detailed implementation plans through interactive questions, parallel research agents and template files for context, research, plan and tasks, from an issue or a plan name.

    263 GitHub stars~5.6k tokensUpdated 7 days ago
    Auto-check: warnings

  • Spektacular Knowledge Base Playbook

    jumppad-labs/jumppad

    Routes natural-language requests to look up, add or update entries in a project's knowledge store by calling the spektacular knowledge CRUD commands directly, without a multi-step CLI flow.

    263 GitHub stars~2.5k tokensUpdated 7 days ago
    Auto-check passed

  • Spek Manage Repos

    jumppad-labs/jumppad

    Add a repo to the current Spektacular project through a guided conversation, inspect the registry, and repair a repo's footprint.

    263 GitHub stars~2.6k tokensUpdated 7 days ago
    Auto-check passed

  • Spek New

    jumppad-labs/jumppad

    Create a new Specification for a feature. An agent skill from jumppad-labs/jumppad.

    263 GitHub stars~2.4k tokensUpdated 7 days ago
    Auto-check passed

Works with

Categories

Questions about Go Development Guidelines

What does Go Development Guidelines do?

Sets idiomatic Go conventions with a test-first workflow, using testify/require for assertions and mockery for mocks, for new features, packages and refactors. The skill gives two checklists, one for adding a feature to an existing Go project and one for starting a new service or package. Feature work runs from a small interface through tests, mockery-generated mocks and the implementation, then explicit error handling, integration tests, go vet and gofmt, and godoc comments.

When should I use Go Development Guidelines?

Go Development Guidelines fits situations like: writing a new Go feature test-first; setting up the layout of a new Go service or package; generating mockery mocks and writing testify/require tests; refactoring Go code to follow naming and error-handling conventions.

How do I install Go Development Guidelines in Claude Code?

Run `npx skills add jumppad-labs/jumppad --skill go-dev-guidelines -a claude-code`. Or copy the skill folder (.claude/skills/go-dev-guidelines in jumppad-labs/jumppad) into .claude/skills/go-dev-guidelines in your project. Claude Code loads it when a task matches its description.

How do I install Go Development Guidelines in Codex?

Run `npx skills add jumppad-labs/jumppad --skill go-dev-guidelines -a codex`. Or copy the skill folder (.claude/skills/go-dev-guidelines in jumppad-labs/jumppad) into .agents/skills/go-dev-guidelines in your project. Codex loads it when a task matches its description.

Can I use Go Development Guidelines in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add jumppad-labs/jumppad --skill go-dev-guidelines -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/go-dev-guidelines, .gemini/skills/go-dev-guidelines, .github/skills/go-dev-guidelines and .opencode/skills/go-dev-guidelines in your project.

What does Go Development Guidelines need to run?

Going by SKILL.md and its folder, Go Development Guidelines needs the command-line tools its instructions call (go). Our summary lists: A Go toolchain with testify and mockery available.

Does Go Development Guidelines access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Go Development Guidelines safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Go Development Guidelines use?

Go Development Guidelines is published under the MPL-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Go Development Guidelines use?

About 1.5k tokens (SKILL.md is roughly 6.2k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 26k tokens, read only when the agent opens those files.

What are the alternatives to Go Development Guidelines?

Skills that share tags, products or a category with Go Development Guidelines: Strict Programming Practices (code-yeongyu/oh-my-openagent, 70k stars), Clean Code (jd-solanki/slidev-theme-dracula, 161 stars), Go Guidelines (mhmtszr/go-guidelines, 104 stars) and Agent Implementer Sparc Coder (ruvnet/ruflo, 74k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Go Development Guidelines?

jumppad-labs (a GitHub organization) maintains it in jumppad-labs/jumppad, which has 263 GitHub stars. The repository holds 8 skills in this directory. The repository was last updated on October 1, 2026.

Source: jumppad-labs/jumppad on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.