Development Skill
Angular Migration
Migrate from AngularJS to Angular using hybrid mode, incremental component rewriting, and…
$15
Go Concurrency Patterns
Master Go concurrency with goroutines, channels, sync primitives, and context.
Production-grade Go concurrency built on the CSP philosophy, share memory by communicating, not the other way around. It delivers worker pools, fan-out/fan-in pipelines, bounded concurrency, error groups and graceful shutdown as ready patterns, each wired with context cancellation so goroutines never leak and races get caught.
$15 one-time
Add to a kit → Prices include 20% VAT. · Forged on real agency work · one-time, no lock-in
- Type Skill
- Category Development
- Delivery Email · instant
- License One-time
Inside the run · no black box
See the actual work before you buy it.
Concurrency bugs in Go are mostly missing discipline. This skill chooses channels over mutexes by CSP default, puts ctx.Done() in every select, bounds goroutines before load arrives, and makes the race detector a CI gate.
- Picks the communication primitive first: channel over mutex by CSP default ('share memory by communicating'). Mutex is only allowed for simple counters or read-heavy caches, and the choice gets documented.
- Builds the worker pool or fan-out/fan-in pipeline with the canonical signature func(ctx, <-chan T) <-chan U, so closing the input channel propagates shutdown through every stage. Fan-in waits on a sync.WaitGroup before closing the output, never earlier.
- Puts a ctx.Done() case into every single channel select. A select without it is a goroutine leak, so the skill treats it as a hard rule, with time.After for timeouts and default for non-blocking tries.
- Bounds concurrency before load hits: semaphore.NewWeighted or a buffered struct{} channel for raw limits, errgroup.SetLimit(N) for I/O-bound batches because it bundles limit, error propagation and cancel in one API.
- Wires graceful shutdown: signal.Notify catches SIGINT/SIGTERM, context cancel propagates to all workers, each worker cleans up in its ctx.Done() branch, and a shutdown timeout forces exit if cleanup hangs.
- Runs go test -race and go build -race as a mandatory CI gate, then reviews mutex usage: defer Unlock everywhere, RWMutex for read-heavy paths, sharded map for write-heavy ones.
One power source. 6 lines out.
go-concurrency-patterns · core
core active · 6 lines
- ✓ build a worker pool over
Build a worker pool over a job channel
- ✓ run a fan-out/fan-in pro…
Run a fan-out/fan-in processing pipeline
- ✓ bound concurrency with a
Bound concurrency with a semaphore or errgroup limit
- ✓ fetch multiple urls conc…
Fetch multiple URLs concurrently with first-error cancellation
- ✓ implement graceful shutd…
Implement graceful shutdown on SIGINT/SIGTERM
- ✓ debug and prevent race c…
Debug and prevent race conditions with the -race detector
Yours to keep.
Drag time forward. Watch what stays.
Forever
That's what owning means.
The rented stack
ai writing tool: subscription
expired · access lostanalytics suite: subscription
expired · access lostdesign platform: subscription
expired · access lost(nothing left)
Your forge
-
Stop goroutine leaks by making every channel listen on ctx.Done()
license: perpetual -
Cut API latency with parallel fan-out instead of sequential calls
license: perpetual -
Use far less memory per goroutine than per-thread models, with bounded worker counts
license: perpetual -
Shut down cleanly without losing in-flight work or leaking resources
license: perpetual
subscriptions expire · deeds don't
Everything in the box.
Pick a piece up. Watch it work.
Worker pool, fan-out/fan-in and bounded-concurrency semaphore patterns
6 parts · one working system · ships instantly by email
This wasn't forged for everyone.
- Not for you if you'd rather rent a tool than own one.
- Not for you if you want someone else to run your stack.
- Not for you if you're happy guessing.
For Go engineers building concurrent services, pipelines and worker systems who need leak-free, race-safe patterns with proper context and shutdown handling.
then this was forged for you.Works with
Universal by design: these run in any AI. Delivered in the open Agent Skills + MCP format (native in Claude); ChatGPT, Gemini, Cursor and Copilot adapt the same files their own way.
- Claude Native format
- ChatGPT Adapts via open standards
- Gemini Adapts via open standards
- Cursor Adapts via open standards
- Copilot Adapts via open standards
Catch what's on your mind.
the air is clear. nothing between you and the forge.
catch a spark: the forge will answer
-
I'm writing a small CLI tool, not a big service, is this overkill?
The patterns scale down. A worker pool, an errgroup limit, or graceful shutdown works the same in a three-file tool as in a service running hundreds of goroutines, and context cancellation prevents leaks at any size.
-
How does it concretely stop goroutine leaks?
Every channel pattern is wired to listen on ctx.Done(), errgroup cancels the whole group on first error, and SetLimit caps concurrency. For races, the package includes the -race detector commands for test, build, and run.
-
Will it speed up single-threaded, CPU-bound code?
No. These patterns parallelize work that waits on I/O: network calls, channels, pipelines. Single-core algorithm optimization and GC tuning are different problems this package doesn't address.
-
How is it delivered?
By email right after purchase: ready to run, downloaded instantly, no setup wait.
-
One-time or subscription?
A one-time purchase; no subscription or hidden fees. VAT (20%) is included.
-
Can I get a refund?
As a digital product, it can’t be refunded once downloaded. That’s why we show exactly what’s inside and who it’s for, right here.