go-concurrency-practice

Detect and fix Go concurrency issues like goroutine leaks and data races.

15|Updated Mar 4, 2026
One-click install
npx skills add https://github.com/v0lka/skills --skill go-concurrency-practice
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: go-concurrency-practice
Source: https://github.com/v0lka/skills/tree/main/development/idiomatic-go/go-concurrency-practice
Command: npx skills add https://github.com/v0lka/skills --skill go-concurrency-practice

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Go developers frequently struggle with concurrency mistakes such as goroutine leaks, data races, and improper context propagation. This skill codifies practical rules and patterns to prevent these issues during coding and reviews.

Core Features & Use Cases

  • Enforces Go concurrency guidelines from common mistakes and best practices.
  • Provides patterns for safe goroutine lifecycle, context handling, and loop variable capture.
  • Use in code reviews, onboarding, and educational sessions to improve concurrency quality.

Quick Start

Apply this skill during code review to identify and fix Go concurrency mistakes in your concurrent code.

Frequently Asked Questions about go-concurrency-practice

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

FAQPage Schema
How do I find and fix goroutine leaks and data races in Go?

To fix goroutine leaks and data races in Go, apply concurrency best practices during code review to detect improper context propagation and channel misuse, then implement safe goroutine lifecycle patterns.

What causes deadlocks and data races in Go maps and slices?

Deadlocks and data races in Go maps and slices occur from improper synchronization. Enforcing guidelines during code review detects channel misuse and context leaks, providing actionable guidance to rectify these concurrency issues.

How to prevent loop-variable capture issues in Go goroutines?

Prevent loop-variable capture in Go goroutines by applying codified patterns from common mistakes guides during refactoring to ensure safe variable capture and proper context handling in concurrent codebases.

Can I use Go concurrency guidelines to review select statements and WaitGroup usage?

Yes, you can use Go concurrency guidelines to review select statements and WaitGroup usage. Applying these rules identifies channel misuse and deadlocks, ensuring safe concurrent code across review contexts.

What is the best way to handle context propagation in Go channels?

The best way to handle context propagation in Go channels is enforcing best practices from common mistakes guides during code review, which identifies context leaks and provides actionable guidance for safe concurrent execution.