skeeper: Skill for Claude Code

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