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 unxed in 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…

MITAuto-check passedDevelopment

Install Golang Concurrency

skills CLI
$ npx skills add unxed/f4 --skill golang-concurrency -a claude-code

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

GitHub CLI
$ gh skill install unxed/f4 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/unxed/f4.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
244
Used in
1 other repo
Token cost
~2.4k tokens
SKILL.md length
941 words
Files
5 (incl. references)
Skills in repo
36
Repo updated
First seen
Licence
MIT

At a glance

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…

  • 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
  • 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 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, worker pools, and fan-out/fan-in pipelines. Use when writing or reviewing concurrent Go code, when choosing between channels and mutexes, when protecting a shared map or counter, or when a goroutine has no clear exit. Not for defensive coding unrelated to concurrency such as nil panics, slice aliasing, or numeric overflow…

Its SKILL.md is about 2.4k 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: dual pane like a charm. The licence is MIT.

When your agent uses it

  • Reviewing concurrent Go code
  • Choosing between channels and mutexes
  • Protecting a shared map
  • A goroutine has no clear exit

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 447642e. 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.4k tokens when it runs, and up to ~7.5k if it reads all its reference files. Until then it costs about 188 tokens; SKILL.md has 941 words of instructions outside code blocks.

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

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 unxed/f4 at commit 447642e, republished under its MIT licence (© unxed). 941 words, ~2,370 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 design — goroutine lifecycle and leak prevention, channels and `select`, channel ownership and direction, `sync.Mutex`/`RWMutex`/`sync.Map`/`sync.Once`/atomics, `errgroup`, `singleflight`, worker pools, and fan-out/fan-in pipelines. Use when writing or reviewing concurrent Go code, when choosing between channels and mutexes, when protecting a shared map or counter, or when a goroutine has no clear exit. Not for defensive coding unrelated to concurrency such as nil panics, slice aliasing, or numeric overflow (→ See `samber/cc-skills-golang@golang-safety` skill), and not for debugging a specific hung, crashing, or racing program after the fact (→ See `samber/cc-skills-golang@golang-troubleshooting` skill).
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.1
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 (350 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
Goroutine leak profile

The goroutine leak profile (experimental behind GOEXPERIMENT=goroutineleakprofile in Go 1.26) is generally available in runtime/pprof since Go 1.27 — no build flag required. It is a useful production-oriented leak signal alongside the existing tools below.

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

© unxed, 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 unxed/f4.

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

Open the folder on GitHubat commit 447642e

Used in 1 other repository

We found 1 copy of this SKILL.md (exact, near-identical or edited) in other folders, from 1 other GitHub owner. This page covers the copy in unxed/f4, which our catalogue first saw on October 7, 2026.

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 skillunxed/f42441 repos~2.4kAutomated 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 Prodavila7/claude-code-templates33k8 repos~1.9kAutomated safety check: PassMIT
Golang Concurrencycontext-labs/whip1.1k—~2.3kAutomated 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 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 Concurrency

    context-labs/whip

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

    1.1k GitHub stars~2.3k tokensUpdated 6 days ago
    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 unxed/f4

All 36 skills in this repo

  • Golang Documentation

    unxed/f4

    Comprehensive documentation guide for Golang projects, covering godoc comments, README, CONTRIBUTING, CHANGELOG, Go Playground, Example tests, API docs, and llms.txt.

    244 GitHub starsUsed in 3 repos~3.5k tokens
    Auto-check passed

  • Golang Code Style

    unxed/f4

    Golang code style conventions — line length and breaking, variable declarations, control flow clarity, when comments help vs hurt.

    244 GitHub starsUsed in 3 repos~2.5k tokens
    Auto-check passed

  • Golang Database

    unxed/f4

    Comprehensive guide for Go database access — parameterized queries, struct scanning, NULLable columns, transactions, isolation levels, SELECT FOR UPDATE, connection pool, batch processing, context…

    244 GitHub starsUsed in 2 repos~2.9k tokens
    Auto-check passed

  • Aif Security Checklist

    unxed/f4

    Security audit checklist based on OWASP Top 10 and best practices.

    244 GitHub stars~5.4k tokensUpdated yesterday
    Auto-check: notes

  • Golang Naming

    unxed/f4

    Go (Golang) naming conventions — covers packages, constructors, structs, interfaces, constants, enums, errors, booleans, receivers, getters/setters, functional options, acronyms, test functions, and…

    244 GitHub starsUsed in 2 repos~3.1k tokens
    Auto-check passed

  • Golang Testing

    unxed/f4

    Production-ready Golang tests — table-driven tests, testify suites and mocks, parallel tests, fuzzing, fixtures, goroutine leak detection with goleak, snapshot testing, code coverage, integration…

    244 GitHub starsUsed in 1 repo~4.5k tokens
    Auto-check passed

Works with

Categories

Questions about Golang Concurrency

What does Golang Concurrency do?

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…. Golang Concurrency is an agent skill from unxed/f4.Once/atomics, errgroup, singleflight, worker pools, and fan-out/fan-in pipelines.

When should I use Golang Concurrency?

Golang Concurrency fits situations like: reviewing concurrent Go code; choosing between channels and mutexes; protecting a shared map; A goroutine has no clear exit.

How do I install Golang Concurrency in Claude Code?

Run `npx skills add unxed/f4 --skill golang-concurrency -a claude-code`. Or copy the skill folder (.agents/skills/golang-concurrency in unxed/f4) 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 unxed/f4 --skill golang-concurrency -a codex`. Or copy the skill folder (.agents/skills/golang-concurrency in unxed/f4) 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 unxed/f4 --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.4k tokens (SKILL.md is roughly 9.5k 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 5.2k 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 Pro (davila7/claude-code-templates, 33k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Golang Concurrency?

unxed (a GitHub user) maintains it in unxed/f4, which has 244 GitHub stars. The repository holds 36 skills in this directory. The repository was last updated on October 10, 2026.

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