New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Golang Concurrency

by context-labs in context-labs/whip

Golang concurrency patterns. An agent skill from context-labs/whip.

MITAuto-check passedDevelopment

Install Golang Concurrency

skills CLI
$ npx skills add context-labs/whip --skill golang-concurrency -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install context-labs/whip golang-concurrency --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/context-labs/whip.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/golang-concurrency .claude/skills/golang-concurrency && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
golang-concurrency
GitHub stars
1.1k
Token cost
~2.3k tokens
SKILL.md length
949 words
Files
5 (incl. references)
Skills in repo
40
Repo updated
First seen
Licence
MIT

At a glance

Golang concurrency patterns. An agent skill from context-labs/whip.

  • Works in 9 steps: Every goroutine must have a clear exit —… → Share memory by communicating — channels… → Send copies, not pointers on channels —… → …
  • Reviewing concurrent Go code — goroutines
  • SKILL.md covers Core Principles, Channel vs Mutex vs Atomic, WaitGroup vs errgroup and Sync Primitives Quick Reference, plus 6 more sections
  • Calls go and curl

What it does

Golang Concurrency is an agent skill from context-labs/whip. Golang concurrency patterns. Use when writing or reviewing concurrent Go code — goroutines, channels, select, locks, sync primitives, errgroup, singleflight, worker pools, fan-out/fan-in — or for goroutine leaks, race conditions, channel ownership, or choosing channels vs mutexes.

Its SKILL.md is about 2.3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 6 other files, including reference files (for example `evals/evals.json`, `references/channels-and-select.md` and `references/pipelines.md`). Compatibility notes: Designed for Claude Code, Codex or similar harness, and for projects using Golang.

It sits in Development, covering Async programming. It works with Go. The repository describes itself as: A fast coding-agent harness in Go. Tool-use loop, bubbletea TUI, provider-routable models with live catalog discovery, MCP support, background subagents. One binary, no runtime… The licence is MIT.

When your agent uses it

  • Reviewing concurrent Go code — goroutines
  • Sync primitives
  • Fan-out/fan-in —
  • For goroutine leaks

Example prompts

  • “/golang-concurrency”

Requirements

  • Compatibility (from SKILL.md): Designed for Claude Code, Codex or similar harness, and for projects using Golang.
  • Pre-approved tools (allowed-tools): Read, Edit, Write, Glob, Grep, Bash(go:*), Bash(golangci-lint:*), Bash(git:*), Agent, AskUserQuestion

Workflow steps

9 steps, taken from the first numbered list in SKILL.md.

  1. Every goroutine must have a clear exit — without a shutdown mechanism (context, done channel, WaitGroup), they leak and accumulate until…
  2. Share memory by communicating — channels transfer ownership explicitly; mutexes protect shared state but make ownership implicit
  3. Send copies, not pointers on channels — sending pointers creates invisible shared memory, defeating the purpose of channels
  4. Only the sender closes a channel — closing from the receiver side panics if the sender writes after close
  5. Specify channel direction (chan<-, <-chan) — the compiler prevents misuse at build time
  6. Default to unbuffered channels — larger buffers mask backpressure; use them only with measured justification
  7. Always include ctx.Done() in select — without it, goroutines leak after caller cancellation
  8. Avoid repeated time.After in hot loops — each call allocates a timer and creates unnecessary churn; use time.NewTimer + Reset for…
  9. Track goroutine leaks in tests with go.uber.org/goleak

What it can do on your machine

Read from SKILL.md and the folder at commit 8876467. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Edit
    • Write
    • Glob
    • Grep
    • Bash(go:*)
    • Bash(golangci-lint:*)
    • Bash(git:*)
    • Agent
    • AskUserQuestion

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • go
    • curl

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • go.dev

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

  • Compatibility

    Designed for Claude Code, Codex or similar harness, and for projects using Golang.

    From compatibility in the SKILL.md frontmatter.

Context cost

Golang Concurrency loads about 2.3k tokens when it runs, and up to ~7.1k if it reads all its reference files. Until then it costs about 75 tokens; SKILL.md has 949 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~75
When it runs · the whole SKILL.md, loaded when a task matches
~2.3k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~7.1k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from context-labs/whip at commit 8876467, republished under its MIT licence (© context-labs). 949 words, ~2,268 tokens.

Download SKILL.mdSave it as .claude/skills/golang-concurrency/SKILL.md (or your agent's skills folder). This skill also uses 4 other files; get the full folder from GitHub.
name
golang-concurrency
description
Golang concurrency patterns. Use when writing or reviewing concurrent Go code — goroutines, channels, select, locks, sync primitives, errgroup, singleflight, worker pools, fan-out/fan-in — or for goroutine leaks, race conditions, channel ownership, or choosing channels vs mutexes.
allowed-tools
Read, Edit, Write, Glob, Grep, Bash(go:*), Bash(golangci-lint:*), Bash(git:*), Agent, AskUserQuestion
compatibility
Designed for Claude Code, Codex or similar harness, and for projects using Golang.
user-invocable
true
license
MIT
metadata.author
samber
metadata.version
1.2.0
paths
**/*.go

Persona: You are a Go concurrency engineer. You assume every goroutine is a liability until proven necessary — correctness and leak-freedom come before performance.

Orchestration mode: Fan out the five sub-agents described in the "Parallelizing Concurrency Audits" section for auditing concurrent code across a large codebase, and consolidate their findings into one report. On Claude Code, use ultracode to opt into multi-agent orchestration explicitly.

Modes:

  • Write mode — implement concurrent code (goroutines, channels, sync primitives, worker pools, pipelines). Follow the sequential instructions below.
  • Review mode — reviewing a PR's concurrent code changes. Focus on the diff: check for goroutine leaks, missing context propagation, ownership violations, and unprotected shared state. Sequential.
  • Audit mode — auditing existing concurrent code across a codebase. Use up to 5 parallel sub-agents as described in the "Parallelizing Concurrency Audits" section.

Community default. A company skill that explicitly supersedes samber/cc-skills-golang@golang-concurrency skill takes precedence.

Go Concurrency Best Practices

Go's concurrency model is built on goroutines and channels. Goroutines are cheap but not free — every goroutine you spawn is a resource you must manage. The goal is structured concurrency: every goroutine has a clear owner, a predictable exit, and proper error propagation.

Core Principles

  1. Every goroutine must have a clear exit — without a shutdown mechanism (context, done channel, WaitGroup), they leak and accumulate until the process crashes
  2. Share memory by communicating — channels transfer ownership explicitly; mutexes protect shared state but make ownership implicit
  3. Send copies, not pointers on channels — sending pointers creates invisible shared memory, defeating the purpose of channels
  4. Only the sender closes a channel — closing from the receiver side panics if the sender writes after close
  5. Specify channel direction (chan<-, <-chan) — the compiler prevents misuse at build time
  6. Default to unbuffered channels — larger buffers mask backpressure; use them only with measured justification
  7. Always include ctx.Done() in select — without it, goroutines leak after caller cancellation
  8. Avoid repeated time.After in hot loops — each call allocates a timer and creates unnecessary churn; use time.NewTimer + Reset for long-running loops
  9. Track goroutine leaks in tests with go.uber.org/goleak

For detailed channel/select code examples, see Channels and Select Patterns.

Channel vs Mutex vs Atomic

ScenarioUseWhy
Passing data between goroutinesChannelCommunicates ownership transfer
Coordinating goroutine lifecycleChannel + contextClean shutdown with select
Protecting shared struct fieldssync.Mutex / sync.RWMutexSimple critical sections
Simple counters, flagssync/atomicLock-free, lower overhead
Many readers, few writers on a mapsync.MapOptimized for read-heavy workloads. Concurrent map read/write causes a hard crash
Caching expensive computationssync.Once / singleflightExecute once or deduplicate

WaitGroup vs errgroup

NeedUseWhy
Wait for goroutines, errors not neededsync.WaitGroupFire-and-forget
Wait + collect first errorerrgroup.GroupError propagation
Wait + cancel siblings on first errorerrgroup.WithContextContext cancellation on error
Wait + limit concurrencyerrgroup.SetLimit(n)Built-in worker pool

Sync Primitives Quick Reference

PrimitiveUse caseKey notes
sync.MutexProtect shared stateKeep critical sections short; never hold across I/O
sync.RWMutexMany readers, few writersNever upgrade RLock to Lock (deadlock)
sync/atomicSimple counters, flagsPrefer typed atomics (Go 1.19+): atomic.Int64, atomic.Bool
sync.MapConcurrent map, read-heavyNo explicit locking; use RWMutex+map when writes dominate
sync.PoolReuse temporary objectsAlways Reset() before Put(); reduces GC pressure
sync.OnceOne-time initializationGo 1.21+: OnceFunc, OnceValue, OnceValues
sync.WaitGroupWaiting for simple goroutinesGo 1.25+: prefer wg.Go(func(){ ... }) for fire-and-wait tasks that do not panic and do not need error propagation. For Go <1.25 use Add/Done. For errors/cancellation/limits, use errgroup with context.
x/sync/singleflightDeduplicate concurrent callsCache stampede prevention
x/sync/errgroupGoroutine group + errorsSetLimit(n) replaces hand-rolled worker pools

For detailed examples and anti-patterns, see Sync Primitives Deep Dive.

Show full SKILL.md (358 more words)Show less

Concurrency Checklist

Before spawning a goroutine, answer:

  • How will it exit? — context cancellation, channel close, or explicit signal
  • Can I signal it to stop? — pass context.Context or done channel
  • Can I wait for it? — sync.WaitGroup or errgroup
  • Who owns the channels? — creator/sender owns and closes
  • Should this be synchronous instead? — don't add concurrency without measured need

Pipelines and Worker Pools

For pipeline patterns (fan-out/fan-in, bounded workers, generator chains, Go 1.23+ iterators, samber/ro), see Pipelines and Worker Pools.

Parallelizing Concurrency Audits

When auditing concurrency across a large codebase, use up to 5 parallel sub-agents:

  1. Find all goroutine spawns (go func, go method) and verify shutdown mechanisms
  2. Search for mutable globals and shared state without synchronization
  3. Audit channel usage — ownership, direction, closure, buffer sizes
  4. Find time.After in loops, missing ctx.Done() in select, unbounded spawning
  5. Check mutex usage, sync.Map, atomics, and thread-safety documentation

Common Mistakes

MistakeFix
Fire-and-forget goroutineProvide stop mechanism (context, done channel)
Closing channel from receiverOnly the sender closes
time.After in hot loopReuse time.NewTimer + Reset
Missing ctx.Done() in selectAlways select on context to allow cancellation
Unbounded goroutine spawningUse errgroup.SetLimit(n) or semaphore
Sharing pointer via channelSend copies or immutable values
wg.Add inside goroutineCall Add before go — Wait may return early otherwise
Forgetting -race in CIAlways run go test -race ./...
Mutex held across I/OKeep critical sections short

Cross-References

  • -> See samber/cc-skills-golang@golang-performance skill for false sharing, cache-line padding, sync.Pool hot-path patterns
  • -> See samber/cc-skills-golang@golang-context skill for cancellation propagation and timeout patterns
  • -> See samber/cc-skills-golang@golang-safety skill for concurrent map access and race condition prevention
  • -> See samber/cc-skills-golang@golang-troubleshooting skill for debugging goroutine leaks and deadlocks
  • -> See samber/cc-skills-golang@golang-design-patterns skill for graceful shutdown patterns
  • -> See samber/cc-skills-golang@golang-continuous-integration skill for automated AI-driven code review in CI using these guidelines
Go 1.26 experimental goroutine leak profile

For Go 1.26 diagnostics, there is an experimental goroutine leak profile. It is useful for production-oriented leak investigation, but is gated by GOEXPERIMENT=goroutineleakprofile; do not rely on it as default stable behavior.

Typical usage when the experiment is enabled:

bash
curl http://localhost:6060/debug/pprof/goroutineleak?debug=2
go tool pprof http://localhost:6060/debug/pprof/goroutineleak

Keep existing tools:

  • tests: go.uber.org/goleak
  • runtime count: runtime.NumGoroutine()
  • stack dump: /debug/pprof/goroutine?debug=2
  • race checks: go test -race ./...

References

© context-labs, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 4 other files (references) in .agents/skills/golang-concurrency of context-labs/whip.

  • SKILL.md
  • evals/evals.json
  • references/channels-and-select.md
  • references/pipelines.md
  • references/sync-primitives.md

Open the folder on GitHubat commit 8876467

Compare with similar skills

Golang Concurrency next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Golang Concurrency compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Golang Concurrency this skillcontext-labs/whip1.1k—~2.3kAutomated safety check: PassMIT
Golang Patternsantoniopaya22/go-rest-template1729 repos~3.5kAutomated safety check: PassNone
Context Handling in fp-goIBM/fp-go2k—~4.2kAutomated safety check: PassApache-2.0
Go Concurrencyinference-gateway/inference-gateway214—~2.3kAutomated safety check: PassApache-2.0
Golang Concurrencyunxed/f42441 repos~2.4kAutomated safety check: PassMIT
Golang Prodavila7/claude-code-templates33k8 repos~1.9kAutomated safety check: PassMIT

Similar skills

  • Golang Patterns

    antoniopaya22/go-rest-template

    Idiomatic Go patterns, best practices, and conventions for building robust, efficient, and maintainable Go applications.

    172 GitHub starsUsed in 9 repos~3.5k tokens
    DevelopmentAuto-check passed

  • Context Handling in fp-go

    IBM/fp-go

    Official

    Covers handling Go's context.Context idiomatically in fp-go code: reading and scoping context through operators, timeouts, cancellation and converting ctx-first functions.

    2k GitHub stars~4.2k tokensUpdated today
    DevelopmentAuto-check passed

  • Go Concurrency

    inference-gateway/inference-gateway

    Idiomatic Go concurrency - sync primitives, channel semantics, the select statement, and the standard channel patterns (cancellation/done-channel, fan-out/fan-in, pipeline, or-done, context…

    214 GitHub stars~2.3k tokensUpdated today
    DevelopmentAuto-check passed

  • Golang Concurrency

    unxed/f4

    Golang concurrency design — goroutine lifecycle and leak prevention, channels and select, channel ownership and direction, sync.Mutex/RWMutex/sync.Map/sync.Once/atomics, errgroup, singleflight…

    244 GitHub starsUsed in 1 repo~2.4k tokens
    DevelopmentAuto-check passed

  • Golang Pro

    davila7/claude-code-templates

    Master Go 1.21+ with modern patterns, advanced concurrency, performance optimization, and production-ready microservices.

    33k GitHub starsUsed in 8 repos~1.9k tokens
    DevelopmentAuto-check passed

  • Golang Expert

    RightNow-AI/openfang

    Go programming expert for goroutines, channels, interfaces, modules, and concurrency patterns

    18k GitHub stars~867 tokensUpdated 3 mo ago
    DevelopmentAuto-check passed

More from context-labs/whip

All 40 skills in this repo

  • Golang Lint

    context-labs/whip

    Linting best practices and golangci-lint configuration for Go — running linters, configuring .golangci.yml, nolint suppressions, selecting linters.

    1.1k GitHub starsUsed in 2 repos~1.8k tokens
    Auto-check passed

  • Golang Project Layout

    context-labs/whip

    Golang project layouts and workspaces. An agent skill from context-labs/whip.

    1.1k GitHub starsUsed in 1 repo~1.8k tokens
    Auto-check passed

  • Golang Pkg Go Dev

    context-labs/whip

    Golang package/module docs via godig, a pkg.go.dev API client (CLI + MCP) — APIs, symbols, versions, importers, licenses, vulnerabilities.

    1.1k GitHub starsUsed in 2 repos~3k tokens
    Auto-check passed

  • Golang Stretchr Testify

    context-labs/whip

    Golang testing with stretchr/testify — assert, require, mock, suite: assertions, mock expectations, argument matchers, suite lifecycle, Eventually, JSONEq.

    1.1k GitHub starsUsed in 2 repos~1.8k tokens
    Auto-check passed

  • Golang Continuous Integration

    context-labs/whip

    CI/CD with GitHub Actions for Golang — testing, linting, SAST, security scanning, coverage, Dependabot, Renovate, GoReleaser, release pipelines.

    1.1k GitHub stars~3.5k tokensUpdated 6 days ago
    Auto-check passed

  • Golang Data Structures

    context-labs/whip

    Golang data structures — slices/maps internals (capacity growth, preallocation, hash buckets), slices/maps packages, container/list/heap/ring, strings.Builder vs bytes.Buffer, generic collections…

    1.1k GitHub starsUsed in 1 repo~2.6k tokens
    Auto-check passed

Works with

Categories

Questions about Golang Concurrency

What does Golang Concurrency do?

Golang concurrency patterns. An agent skill from context-labs/whip. Golang Concurrency is an agent skill from context-labs/whip. Golang concurrency patterns.

When should I use Golang Concurrency?

Golang Concurrency fits situations like: reviewing concurrent Go code — goroutines; sync primitives; fan-out/fan-in —; for goroutine leaks.

How do I install Golang Concurrency in Claude Code?

Run `npx skills add context-labs/whip --skill golang-concurrency -a claude-code`. Or copy the skill folder (.agents/skills/golang-concurrency in context-labs/whip) into .claude/skills/golang-concurrency in your project. Claude Code loads it when a task matches its description.

How do I install Golang Concurrency in Codex?

Run `npx skills add context-labs/whip --skill golang-concurrency -a codex`. Or copy the skill folder (.agents/skills/golang-concurrency in context-labs/whip) into .agents/skills/golang-concurrency in your project. Codex loads it when a task matches its description.

Can I use Golang Concurrency in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add context-labs/whip --skill golang-concurrency -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/golang-concurrency, .gemini/skills/golang-concurrency, .github/skills/golang-concurrency and .opencode/skills/golang-concurrency in your project.

What does Golang Concurrency need to run?

Going by SKILL.md and its folder, Golang Concurrency needs the command-line tools its instructions call (go and curl). Its frontmatter pre-approves these tools: Read, Edit, Write, Glob, Grep, Bash(go:*), Bash(golangci-lint:*), Bash(git:*), Agent, AskUserQuestion. Compatibility (from SKILL.md): Designed for Claude Code, Codex or similar harness, and for projects using Golang..

Does Golang Concurrency access the network?

SKILL.md names 1 domain. As links in the text: go.dev. This is read from the text; nothing was executed.

Is Golang Concurrency safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Golang Concurrency use?

Golang Concurrency is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Golang Concurrency use?

About 2.3k tokens (SKILL.md is roughly 9.1k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 4.8k tokens, read only when the agent opens those files.

What are the alternatives to Golang Concurrency?

Skills that share tags, products or a category with Golang Concurrency: Golang Patterns (antoniopaya22/go-rest-template, 172 stars), Context Handling in fp-go (IBM/fp-go, 2k stars), Go Concurrency (inference-gateway/inference-gateway, 214 stars) and Golang Concurrency (unxed/f4, 244 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Golang Concurrency?

context-labs (a GitHub organization) maintains it in context-labs/whip, which has 1,083 GitHub stars. The repository holds 40 skills in this directory. The repository was last updated on October 5, 2026.

Source: context-labs/whip on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.