Golang Idiomatic Go

Golang Idiomatic Patterns

Expert-level review for idiomatic Go patterns. Ensures code follows Go conventions, proper interface design, and appropriate pointer usage.

When to Apply

Use this skill when:

• Ensuring code follows Go idioms
• Reviewing interface design patterns
• Checking pointer vs value usage
• Verifying "Accept interfaces, return structs" pattern
• Auditing usecase complexity
• Ensuring small, focused interfaces

Rule Categories by Priority

Rules Covered (6 total)

High-Impact Patterns (1)

• high-pointer-receiver - Use pointer receivers for mutations

Medium Improvements (5)

• medium-interface-pollution - Keep interfaces small (<5 methods)
• medium-accept-interface-return-struct - API flexibility pattern
• medium-pointer-overuse - Don't overuse pointers for small types
• medium-usecase-complexity - Move business logic to domain entities
• medium-interface-in-implementation - Define interfaces where used

Common Idiomatic Patterns

Accept Interfaces, Return Structs

// ✅ GOOD: Accept interface, return struct
func Process(r io.Reader) (*Result, error) {
    // ...
    return &Result{}, nil
}

Small Interfaces

// ✅ GOOD: Small, focused interface
type Reader interface {
    Read(p []byte) (n int, err error)
}

Pointer Receivers for Mutations

// ✅ GOOD: Pointer receiver modifies state
func (u *User) UpdateEmail(email string) {
    u.Email = email
}

Trigger Phrases

This skill activates when you say:

• "Is this idiomatic Go?"
• "Review Go style"
• "Check interface design"
• "Verify pointer usage"
• "Review Go conventions"
• "Check for Go anti-patterns"

How to Use

For Idiomatic Review

1. Check method receivers (pointer vs value)
2. Verify interface sizes and locations
3. Review pointer usage appropriateness
4. Check "accept interfaces, return structs" pattern

Output Format

## Idiomatic Go Improvements: X

### [Rule Name] (Line Y)
**Pattern**: Interface Design / Pointer Usage / Method Receiver
**Issue**: Violates Go idiom
**Fix**: Suggested correction
**Example**:
```go
// Idiomatic Go code

Related Skills

• golang-clean-architecture - For interface segregation
• golang-design-patterns - For usecase complexity

Philosophy

Based on "Learning Go" and Effective Go:

• Simplicity over cleverness - Boring code is good code
• Interfaces are satisfied implicitly - Define where used
• Composition over inheritance - Embed types, don't extend
• Clear is better than clever - Readability wins

Notes

• Focus on Go-specific patterns
• Not general programming practices
• Emphasizes Go conventions and idioms
• Based on Effective Go and community standards