Effective Go Mastery

What this skill does

• •Applies standard naming conventions for exported and internal symbols
• •Validates error handling patterns and prevents improper panic usage
• •Enforces interface minimalism by suggesting smaller method sets
• •Standardizes documentation comments for all exported types and functions
• •Automates formatting compliance to match the official gofmt standard

When to use it

• ✓Reviewing pull requests for stylistic or idiomatic deviations
• ✓Refactoring monolithic packages into smaller, interface-driven components
• ✓Onboarding new team members to project-specific coding standards
• ✓Preparing internal packages for public release or long-term maintenance

When not to use it

• ✕When working in languages other than Go
• ✕When applying architectural changes that require non-idiomatic performance hacks for high-frequency low-latency paths

How to invoke it

Example prompts that trigger this skill:

• “Refactor this package to follow Effective Go conventions.”
• “Review this code and suggest changes to improve idiomatic Go usage.”
• “Apply Go naming and error handling best practices to this file.”
• “Identify non-idiomatic patterns in my current implementation.”
• “Clean up this struct and interface design based on Effective Go.”

Example workflow

1. Analyze the target Go file or directory for stylistic issues.
2. Identify deviations from standard naming and error checking patterns.
3. Execute refactoring suggestions to adhere to idiomatic interface designs.
4. Verify the code against gofmt formatting standards.
5. Generate documentation comments for all exported symbols.

Prerequisites

• –Go runtime environment installed locally
• –Project directory structured according to standard Go workspace conventions

Pitfalls & limitations

• !May suggest changes that break backward compatibility if applied to existing public APIs
• !Does not account for non-standard library performance optimizations required in highly specific hardware-interfacing code

FAQ

How it compares

Unlike a generic prompt, this skill is pre-configured with the specific constraints of the official Go style guide, ensuring consistent, reproducible results across your entire project.

Source & trust

From the source: “# Effective Go Apply best practices and conventions from the official [Effective Go guide](https://go.dev/doc/effective_go) to write clean, idiomatic Go code. ## When to Apply Use this skill automatically when: - Writing new Go code - Reviewing Go code - Refactoring existing Go implementations ## Ke…”

# Effective Go

Apply best practices and conventions from the official [Effective Go guide](https://go.dev/doc/effective_go) to write clean, idiomatic Go code.

## When to Apply

Use this skill automatically when:
- Writing new Go code
- Reviewing Go code
- Refactoring existing Go implementations

## Key Reminders

Follow the conventions and patterns documented at https://go.dev/doc/effective_go, with particular attention to:

- **Formatting**: Always use `gofmt` - this is non-negotiable
- **Naming**: No underscores, use MixedCaps for exported names, mixedCaps for unexported
- **Error handling**: Always check errors; return them, don't panic
- **Concurrency**: Share memory by communicating (use channels)
- **Interfaces**: Keep small (1-3 methods ideal); accept interfaces, return concrete types
- **Documentation**: Document all exported symbols, starting with the symbol name

## References

- Official Guide: https://go.dev/doc/effective_go
- Code Review Comments: https://github.com/golang/go/wiki/CodeReviewComments
- Standard Library: Use as reference for idiomatic patterns

Quoted from openshift/hypershift for reference — see the original for the authoritative, latest version.

Recommended Rules

Recommended Workflows

Recommended MCP Servers