audit-go

Audit Go source code for idiomatic patterns, error handling, concurrency, and performance issues.

4|1|Updated Dec 7, 2025
One-click install
npx skills add https://github.com/cacack/my-family --skill audit-go
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: audit-go
Source: https://github.com/cacack/my-family/tree/main/.claude/skills/audit-go
Command: npx skills add https://github.com/cacack/my-family --skill audit-go

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps developers and maintainers identify non-idiomatic Go patterns, fragile error handling, unsafe concurrency, poor package boundaries, and performance risks so codebases become more maintainable and reliable.

Core Features & Use Cases

  • Targeted Go idioms audit: checks error wrapping, sentinel errors, swallowed errors, panic misuse, and command handler propagation.
  • Package, interface, and concurrency review: inspects package layout, circular imports, interface placement, goroutine lifecycles, and context propagation.
  • Use Case: A maintainer preparing a release samples files across internal/domain packages, uncovers N+1 query patterns and improper error handling, and generates issue-ready remediation tickets.

Quick Start

Ask the audit-go skill to sample five Go files across different packages and produce a scorecard with top findings and actionable GitHub-issue-ready tickets.

Frequently Asked Questions about audit-go

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

FAQPage Schema
How do I audit Go source code for idiomatic patterns and performance issues?

To audit Go code, sample multiple packages including internal domain boundaries and cmd entry points, evaluating error handling, concurrency, package design, and performance to produce a scorecard with ranked findings and issue-ready tickets.

What are common non-idiomatic Go patterns to check for during a code review?

Common non-idiomatic Go patterns include fragile error handling like swallowed errors, unsafe goroutine lifecycles, poor package boundaries, circular imports, and improper context propagation that reduce codebase maintainability.

How do I generate GitHub-issue-ready tickets for Go codebase improvements?

Generate GitHub-issue-ready tickets by auditing Go repositories for concurrency and error handling issues, producing ranked findings with precise file-level evidence and manual verification items relying on repository files.

Can I use this audit to check Go package design and interface placement?

Yes, you can audit Go package design and interface placement by inspecting package layout, checking for circular imports, and evaluating interface placement and goroutine lifecycles across sampled files.

What is the best way to find fragile error handling and unsafe concurrency in Go?

The best way to find fragile error handling and unsafe concurrency is sampling Go files across domain boundaries to check error wrapping, sentinel errors, panic misuse, and context propagation.

Does the Go audit require external dependencies or documented conventions?

No, the Go audit relies only on repository files and documented conventions, requiring no external dependencies to evaluate code health and produce actionable remediation items.