golang-troubleshooting

Reproduce Go bugs deterministically and diagnose root causes with go test, race detector, pprof, and Delve.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Go developers often struggle to debug complex issues where symptoms mislead and root causes remain hidden. This section helps establish a repeatable, evidence-based workflow to locate and fix the underlying problem.

Core Features & Use Cases

  • Structured, evidence-driven debugging methodology tailored for Go applications.
  • Guidance on reproducing failures, instrumenting code, and measuring impact with tools like pprof, race detector, and Delve.
  • Reference material for common Go bugs (nil pointers, data races, interface nil, defer pitfalls) and how to trace upstream causes.

Quick Start

Describe a reproducible failing scenario and follow the guide to instrument, reproduce, measure, and fix with one hypothesis at a time.

Frequently Asked Questions about golang-troubleshooting

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

FAQPage Schema
How do I find the root cause of a Go data race or nil pointer bug?

To find the root cause of a Go bug, reproduce it deterministically and apply a single-hypothesis debugging approach using the race detector and Delve to trace upstream causes. This isolates the exact failure scenario rather than addressing misleading symptoms.

How do I debug a Go application that only fails intermittently?

Debug an intermittent Go failure by establishing a repeatable, evidence-based workflow using go test and the race detector to reproduce failures deterministically. Instrumenting code and measuring impact with pprof confirms the exact bug scenario before applying fixes.

What is the best way to profile Go performance issues and trace memory leaks?

The best way to profile Go performance and trace memory leaks is using pprof to measure impact and locate root causes. This evidence-driven methodology ensures you identify the exact bug scenario through instrumentation rather than guessing at symptoms.

Can I use Delve and pprof together for systematic Go debugging?

Yes, you can use Delve and pprof together for systematic Go debugging by instrumenting code and measuring impact. This combination supports a single-hypothesis-at-a-time approach to locate root causes and provides a reproducible failing test for verification.

Why does my Go test pass locally but fail with a data race in production?

A Go test passing locally but failing with a data race indicates a concurrency bug that requires deterministic reproduction. Using the race detector and go test within a single-hypothesis debugging approach traces the upstream cause of the hidden race condition.

How do I fix common Go defer pitfalls and interface nil issues?

Fix common Go defer pitfalls and interface nil issues by documenting the exact bug scenario and tracing upstream causes with Delve. This systematic approach yields a root-cause fix plan with verification steps to prevent recurrence.