golang patterns

Other Community

Skill notes

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

Core Workflow

Analyze architecture — Review module structure, interfaces, and concurrency patterns Design interfaces — Small, focused, defined at the consumer; composition over inheritance Implement — 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

Core Pattern Example

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

MUST DO

Run gofmt and golangci-lint on all code Add context.Context as first param on all blocking operations Handle every error explicitly (no naked _ discards without justification) Write table-driven tests with subtests Document all exported functions, types, and packages

MUST NOT DO

Ignore errors (no _ = thatMightFail() without a comment) Use panic for normal error handling Spawn goroutines without a clear lifecycle Skip context cancellation handling Reach for reflection without a measured performance reason

Fluxly profile Runtime and permissions are inferred by Fluxly static checks, not author declarations or runtime test results.
Domain
Other
Author-declared agents
No explicit declaration found; this is not inferred or tested compatibility
Static check
88 / 100 · heuristic scan, not runtime safety proof
Runtime evidence
Not run; no isolated runtime test evidence is currently recorded
Author / version / license
@tomevault-io · no license declared
Token usage
Lean
Setup complexity
Guided setup
External API key
Not required
Operating systems
Unspecified (assume cross-platform)
Runtime requirements
No explicit requirements detected
Detected file/system behavior
  • Read-only
  • Write / modify
  • Shell exec
  • Env read
Network behavior
Local-only
Install commands
None (reference only)

Heads up: Tool permissions are not declared; actual access depends on the runtime.

Output preview golang-patterns.preview
# Core Pattern Example

// worker runs until ctx is cancelled or an error occurs.
// Errors are returned via errCh; 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())
    }
}

Discussion

Powered by GitHub Discussions. Sign in with GitHub to comment, react, or subscribe.