golang-pro

Jeffallan/claude-skillsCoding AgentsAudit passedSnapshot 382da766ed97

Installs: 0

Summary

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.

SKILL.md

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

Analyze architecture — Review module structure, interfaces, and concurrency patterns
Design interfaces — Create small, focused interfaces with composition
Implement — Write idiomatic Go with proper error handling and context propagation; run go vet ./... before proceeding
Lint & validate — Run golangci-lint run and fix all reported issues before proceeding
Optimize — Profile with pprof, write benchmarks, eliminate allocations
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

// worker runs until ctx is cancelled or an error occurs.
// Errors are returned via the errCh channel; the caller must drain it.
func worker(ctx context.Context, jobs <-chan Job, errCh chan<- error) {
    for {
        select {
        case <-ctx.Done():
            errCh <- fmt.Errorf("worker cancelled: %w", ctx.Err())
            return
        case job, ok := <-jobs:
            if !ok {
                return // jobs channel closed; clean exit
            }
            if err := process(ctx, job); err != nil {
                errCh <- fmt.Errorf("process job %v: %w", job.ID, err)
                return
            }
        }
    }
}

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)

    go worker(ctx, jobCh, errCh)

    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())
    }
}

golang-pro

Summary

SKILL.md

Golang Pro

Core Workflow

Reference Guide

Core Pattern Example

Constraints

MUST DO

MUST NOT DO

Output Templates

Knowledge Reference

Related skills