go-concurrency-reviewer

Audit Go codebases for concurrency defects and generate remediation reports.

1|Updated Mar 23, 2026
One-click install
npx skills add https://github.com/RaNDoM6913/claude-code-superkit --skill go-concurrency-reviewer
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: go-concurrency-reviewer
Source: https://github.com/RaNDoM6913/claude-code-superkit/tree/main/packages/codex/skills/go-concurrency-reviewer
Command: npx skills add https://github.com/RaNDoM6913/claude-code-superkit --skill go-concurrency-reviewer

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Audit Go concurrency to detect and fix goroutine leaks, race conditions, and context propagation issues.

Core Features & Use Cases

  • Phase-based auditing: Phase 1 quick scan ensures every goroutine has a shutdown mechanism, proper context handling, and safe channel usage.
  • Phase 2 deep analysis: evaluates concurrency patterns, deadlock risks, and race conditions with a structured methodology.
  • Audit Mode: dispatches sub-agents to verify lifecycle, shared state protection, channel safety, timer/context usage, and synchronization primitives.
  • Cross-References: links to Go concurrency patterns and best practices for deeper learning.

Quick Start

Run the reviewer against your Go project to generate a concurrency audit report.

Frequently Asked Questions about go-concurrency-reviewer

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I detect and fix goroutine leaks in my Go code?▼

To detect goroutine leaks, run a concurrency audit that enforces a phased checklist ensuring every goroutine has a shutdown mechanism, proper context handling, and safe channel usage, generating a remediation report.

Why does my Go application experience deadlocks and race conditions?▼

Deadlocks and race conditions occur due to unsafe shared state protection and improper synchronization. A deep concurrency audit evaluates patterns, channel safety, and synchronization primitives to identify and remediate these defects.

What is the best way to audit Go concurrency patterns in a large project?▼

The best way to audit Go concurrency is using a structured phase-based methodology that dispatches sub-agents to verify lifecycle, shared state protection, channel safety, timer usage, and synchronization primitives across the codebase.

Can I check if my Go channels and context propagation are safe to use?▼

Yes, you can check channel and context safety by running an audit mode that dispatches sub-agents to verify safe channel usage, proper context propagation, and timer or context usage across your Go project.

Does this concurrency audit cover established Go patterns and best practices?▼

Yes, the concurrency audit covers established Go patterns and best practices by providing cross-references that link identified defects to deeper learning resources for safe, leak-free code.