golang-troubleshooting

Troubleshoots Go program crashes, races, deadlocks and hangs using evidence-first root cause analysis.

Updated May 28, 2026
One-click install
npx skills add https://github.com/vanstinator/semantic-search --skill golang-troubleshooting-vanstinator
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: golang-troubleshooting
Source: https://github.com/vanstinator/semantic-search/tree/main/.agents/skills/golang-troubleshooting
Command: npx skills add https://github.com/vanstinator/semantic-search --skill golang-troubleshooting-vanstinator

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires go, dlv, and includes references (resource) components.

What problem does it solve?

This Skill helps you systematically diagnose and fix crashes, panics, deadlocks, hangs, races, and other unexpected behavior in Go programs without masking the underlying defect.

Core Features & Use Cases

  • Evidence-first debugging: read the error, reproduce the issue, then investigate one hypothesis at a time.
  • Concurrency & race triage: use go test -race, goroutine dumps, and targeted concurrency diagnostics for leaks and deadlocks.
  • Production-grade instrumentation: escalate to pprof, Delve, and GODEBUG tracing when simpler checks aren’t enough.
  • Root-cause enforcement: refuses “symptom fixes” (like adding nil checks) until it traces the cause to its origin.

Quick Start

Ask the Skill to debug your Go failure by first reproducing the bug and then walking the decision tree from the exact symptom and error message.

Frequently Asked Questions about golang-troubleshooting

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

FAQPage Schema
How do I debug a deadlock or race condition in my Go program?

Debug a Go deadlock or race condition by enforcing an evidence-first workflow that reproduces the issue using `go test -race` and goroutine dumps to trace the exact concurrency root cause before proposing fixes.

What is the best way to find the root cause of a Go application crash?

The best way to find a Go crash root cause is reading the error, reproducing the failure, and investigating one hypothesis at a time using Delve and GODEBUG tracing to refuse symptom-masking changes.

How do I troubleshoot a Go program hang using pprof and Delve?

Troubleshoot Go program hangs by escalating to production-grade instrumentation with pprof and Delve when simpler checks fail, walking the decision tree from the exact symptom to identify the underlying logic failure.

Do I need Delve installed to trace goroutine leaks in Go?

Yes, Delve is required to troubleshoot Go goroutine leaks and deadlocks, working alongside `go test -race` and GODEBUG to enforce structured root-cause analysis for complex concurrency symptoms.

Why does adding a nil check fail to fix my unexpected Go behavior?

Adding a nil check fails because it masks the symptom rather than tracing the defect to its origin; root-cause enforcement requires reproducing the issue and investigating the exact error before applying fixes.

Can I use this approach for broader codebase bug hunts across compilation and performance issues?

Yes, this evidence-first troubleshooting workflow applies to broader codebase bug hunts across compilation, correctness, concurrency, and performance symptoms in Go programs using structured diagnostic tooling.