golang pro

Design Community

Skill notes

Guardrails

State assumptions about concurrency, ordering, cancellation, and error handling before coding. Prefer simple functions and small interfaces. Do not introduce goroutines, channels, generics, or microservice boundaries unless the task needs them. Keep edits surgical and local to the requested behavior. Do not reformat or refactor adjacent Go code opportunistically. Verify with targeted tests first; run go test, go vet, race tests, benchmarks, or pprof only when relevant to the change.

Core Workflow

Analyze scope — Review only the modules, interfaces, and concurrency paths touched by the task Choose the simplest design — Create small interfaces only when multiple real implementations or tests need them Implement — Write idiomatic Go with explicit error handling and context propagation where the code path requires it Validate — Run the narrowest useful tests and static checks, then broaden only when shared behavior changed

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 Pattern Example

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

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

Fluxly profile Runtime and permissions are inferred by Fluxly static checks, not author declarations or runtime test results.
Domain
Design
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
Plug-and-play
External API key
Not required
Operating systems
macOS · Linux · Windows
Runtime requirements
No explicit requirements detected
Detected file/system behavior
  • Read-only
  • Write / modify
  • 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-pro.preview
# Core Pattern Example

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

Discussion

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