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

/go-concurrency-patterns

@4220308
by Seth Hobsonwshobson/agents43k stars
4,518
Run it yourself

Master Go concurrency with goroutines, channels, sync primitives, and context. Use when building concurrent Go applications, implementing worker pools, or debugging race conditions.

Use this Skill: https://skilld.dev/gh/wshobson/agents/go-concurrency-patterns

Nothing lands on disk. Nothing to clean up.

Fork this Skill

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

SKILL.md

≈52 tokens for metadata: the name and description. ≈634 when used: this file. ≈2.8k more on demand in 1 file.

Description uses 2.6% 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 ≈207 characters, or 2.6%.

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.

Go Concurrency Patterns

Production patterns for Go concurrency including goroutines, channels, synchronization primitives, and context management.

When to Use This Skill

  • Building concurrent Go applications
  • Implementing worker pools and pipelines
  • Managing goroutine lifecycles
  • Using channels for communication
  • Debugging race conditions
  • Implementing graceful shutdown

Core Concepts

1. Go Concurrency Primitives

Primitive Purpose
goroutine Lightweight concurrent execution
channel Communication between goroutines
select Multiplex channel operations
sync.Mutex Mutual exclusion
sync.WaitGroup Wait for goroutines to complete
context.Context Cancellation and deadlines

2. Go Concurrency Mantra

Don't communicate by sharing memory;
share memory by communicating.

Quick Start

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    results := make(chan string, 10)
    var wg sync.WaitGroup

    // Spawn workers
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go worker(ctx, i, results, &wg)
    }

    // Close results when done
    go func() {
        wg.Wait()
        close(results)
    }()

    // Collect results
    for result := range results {
        fmt.Println(result)
    }
}

func worker(ctx context.Context, id int, results chan<- string, wg *sync.WaitGroup) {
    defer wg.Done()

    select {
    case <-ctx.Done():
        return
    case results <- fmt.Sprintf("Worker %d done", id):
    }
}

Detailed patterns and worked examples

Detailed pattern documentation lives in references/details.md. Read that file when the navigation tier above is insufficient.

Best Practices

Do's

  • Use context - For cancellation and deadlines
  • Close channels - From sender side only
  • Use errgroup - For concurrent operations with errors
  • Buffer channels - When you know the count
  • Prefer channels - Over mutexes when possible

Don'ts

  • Don't leak goroutines - Always have exit path
  • Don't close from receiver - Causes panic
  • Don't use shared memory - Unless necessary
  • Don't ignore context cancellation - Check ctx.Done()
  • Don't use time.Sleep for sync - Use proper primitives

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.

No alerts19d5 checks · Risk SAFE
  • Gen Agent Trust Hub20d

    This skill provides standard educational patterns for Go concurrency, including goroutines, channels, and synchronization primitives. It follows Go best practices and references official Go project libraries. No malicious patterns or security risks were detected.

  • Socket19d

    No alerts

  • Snyk20d

    Risk: LOW · No issues

  • Runlayer8mo

    1 file scanned · No issues

  • ZeroLeaks7mo

    Score: 93/100 · 2 sections analyzed

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

Last checked against GitHub 3 days ago.

Activeupdated 6 months ago
  • Go
  • concurrency
  • goroutines
  • channels
  • context
  • sync
  • worker-pools
  • race-conditions

README badge

README badge for wshobson/agents/go-concurrency-patterns

Teaches Go concurrency patterns including goroutines, channels, sync primitives, and context management for building concurrent applications. Covers worker pools, pipelines, graceful shutdown, and race condition debugging with best practices and worked examples.

Generated from the current SKILL.md.

Does this skill cover context cancellation and timeouts?
Yes. The skill covers context management including context.WithTimeout, context.WithCancel, and checking ctx.Done() for graceful shutdown and deadline handling.
What sync primitives are included?
The skill covers sync.Mutex for mutual exclusion, sync.WaitGroup for waiting on goroutines, channels for communication, and the select statement for multiplexing channel operations.
Does this include worker pool patterns?
Yes. The skill explicitly covers worker pool implementation and provides a quick start example demonstrating spawning and managing multiple concurrent workers with proper lifecycle management.
How does this skill address race conditions?
The skill mentions debugging race conditions and emphasizes communicating via channels rather than sharing memory directly, which is Go's recommended approach for avoiding data races.
Does this cover error handling in concurrent code?
The skill mentions using errgroup for concurrent operations with errors as a best practice, though detailed error handling patterns are referenced in the details.md file.

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