Index of every page on this site: llms.txt
All skills
jeffallan avatar

/golang-pro

@67c1961
by jeffallanjeffallan/claude-skills12k stars
1,202
Run it yourself

Implements concurrent Go patterns using goroutines and channels, designs and builds microservices with gRPC or REST, optimizes Go application performance with pprof, and enforces idiomatic Go with generics, interfaces, and robust error handling. Use when building Go applications requiring concurrent programming, microservices architecture, or high-performance systems. Invoke for goroutines, channels, Go generics, gRPC integration, CLI tools, benchmarks, or table-driven testing.

Use this Skill: https://skilld.dev/gh/jeffallan/claude-skills/golang-pro

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈124 tokens for metadata: the name and description. ≈1.1k when used: this file. ≈11k more on demand in 5 files.

Description uses 6.2% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈495 characters, or 6.2%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Golang Pro

Senior Go developer with deep expertise in Go 1.21+, concurrent programming, and cloud-native microservices. Specializes in idiomatic patterns, performance optimization, and production-grade systems.

Core Workflow

  1. Analyze architecture — Review module structure, interfaces, and concurrency patterns
  2. Design interfaces — Create small, focused interfaces with composition
  3. Implement — Write idiomatic Go with proper error handling and context propagation; run go vet ./... before proceeding
  4. Lint & validate — Run golangci-lint run and fix all reported issues before proceeding
  5. Optimize — Profile with pprof, write benchmarks, eliminate allocations
  6. Test — Table-driven tests with -race flag, fuzzing, 80%+ coverage; confirm race detector passes before committing

Reference Guide

Load detailed guidance based on context:

Topic Reference Load When
Concurrency references/concurrency.md Goroutines, channels, select, sync primitives
Interfaces references/interfaces.md Interface design, io.Reader/Writer, composition
Generics references/generics.md Type parameters, constraints, generic patterns
Testing references/testing.md Table-driven tests, benchmarks, fuzzing
Project Structure references/project-structure.md Module layout, internal packages, go.mod

Core Pattern Example

Goroutine with proper context cancellation and error propagation:

// worker runs until jobs is closed, ctx is cancelled, or a job fails.
// It returns nil only after draining jobs cleanly.
func worker(ctx context.Context, jobs <-chan Job) error {
    for {
        select {
        case <-ctx.Done():
            return fmt.Errorf("worker cancelled: %w", ctx.Err())
        case job, ok := <-jobs:
            if !ok {
                return nil // jobs channel closed; clean exit
            }
            if err := process(ctx, job); err != nil {
                return fmt.Errorf("process job %v: %w", job.ID, err)
            }
        }
    }
}

func runPipeline(ctx context.Context, jobs []Job) error {
    ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
    defer cancel()

    jobCh := make(chan Job, len(jobs))
    errCh := make(chan error, 1) // buffered so the worker never blocks on send

    go func() { errCh <- worker(ctx, jobCh) }()

    for _, j := range jobs {
        jobCh <- j
    }
    close(jobCh)

    select {
    case err := <-errCh:
        return err
    case <-ctx.Done():
        return fmt.Errorf("pipeline timed out: %w", ctx.Err())
    }
}

Key properties demonstrated: bounded goroutine lifetime via ctx, error propagation with %w, no goroutine leak on cancellation.

Constraints

MUST DO

  • Use gofmt and golangci-lint on all code
  • Add context.Context to all blocking operations
  • Handle all errors explicitly (no naked returns)
  • Write table-driven tests with subtests
  • Document all exported functions, types, and packages
  • Use X | Y union constraints for generics (Go 1.18+)
  • Propagate errors with fmt.Errorf("%w", err)
  • Run race detector on tests (-race flag)

MUST NOT DO

  • Ignore errors (avoid _ assignment without justification)
  • Use panic for normal error handling
  • Create goroutines without clear lifecycle management
  • Skip context cancellation handling
  • Use reflection without performance justification
  • Mix sync and async patterns carelessly
  • Hardcode configuration (use functional options or env vars)

Output Templates

When implementing Go features, provide:

  1. Interface definitions (contracts first)
  2. Implementation files with proper package structure
  3. Test file with table-driven tests
  4. Brief explanation of concurrency patterns used

Knowledge Reference

Go 1.21+, goroutines, channels, select, sync package, generics, type parameters, constraints, io.Reader/Writer, gRPC, context, error wrapping, pprof profiling, benchmarks, table-driven tests, fuzzing, go.mod, internal packages, functional options

Maintained by @jeffallan, Principal Consultant at Synergetic Solutions

Documentation

Source: SKILL.md on GitHub

No rule matched.

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

1 alert25d5 checks · Risk CRITICAL
  • Gen Agent Trust Hub25d

    This skill provides high-quality, professional guidance for Go development. However, a documentation URL referenced in the skill's metadata and footer is currently flagged on a security blacklist by automated scanners.

  • Socket25d

    No alerts

  • Snyk25d

    Risk: LOW · No issues

  • Runlayer8mo

    6 files scanned · No issues

  • ZeroLeaks7mo

    Score: 93/100 · 2 sections analyzed

Signed by skilld at 67c1961. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub 4 days ago.

Activeupdated 4 weeks ago
Other metadata
metadata
{
  "author": "https://github.com/Jeffallan",
  "company": "https://synergetic.solutions",
  "version": "1.1.1",
  "domain": "language",
  "triggers": "Go, Golang, goroutines, channels, gRPC, microservices Go, Go generics, concurrent programming, Go interfaces",
  "role": "specialist",
  "scope": "implementation",
  "output-format": "code",
  "related-skills": "devops-engineer, microservices-architect, test-master"
}
  • Performance
  • Testing
  • golang
  • goroutines
  • channels
  • grpc
  • microservices
  • concurrency
  • generics
  • error-handling

README badge

README badge for jeffallan/claude-skills/golang-pro

Implements concurrent Go patterns using goroutines, channels, and context propagation; designs gRPC and REST microservices; profiles performance with pprof; enforces idiomatic Go with generics, interfaces, and error wrapping. Targets Go 1.21+ applications requiring concurrent programming, microservices architecture, or performance optimization.

Generated from the current SKILL.md.

Does this skill work with Go versions before 1.21?
No. The skill is built for Go 1.21+ and uses features like generics with union constraints that require that version or later.
What happens if I don't run golangci-lint before proceeding?
The skill enforces golangci-lint as a mandatory step in its workflow — all linting issues must be fixed before moving forward.
Does this skill help with gRPC and REST microservices?
Yes. The skill specializes in both gRPC and REST microservice design and implementation as part of its core microservices architecture focus.
Can this skill help optimize Go application performance?
Yes. It includes pprof profiling, benchmark writing, and allocation elimination as part of its optimization workflow.
Does this skill require specific testing coverage?
The skill targets 80%+ test coverage with table-driven tests run under the race detector flag before committing.

Generated from the current SKILL.md. These answers refresh after source changes.