simplicity-hunter-go

Audit Go code for structural complexity and prescribe behavior-preserving simplifications.

5|Updated Jan 14, 2026
One-click install
npx skills add https://github.com/skyosev/agent-skills --skill simplicity-hunter-go
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: simplicity-hunter-go
Source: https://github.com/skyosev/agent-skills/tree/main/hunter-party-go/simplicity-hunter-go
Command: npx skills add https://github.com/skyosev/agent-skills --skill simplicity-hunter-go

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Audit Go code for unnecessary structural complexity — duplication, avoidable abstractions, dead logic paths, over-parameterized APIs, deep nesting, interface pollution, channel misuse, and mixed concerns. Recommends the simplest shape that preserves intended behavior.

Core Features & Use Cases

  • Identify duplication across functions, packages, and tests.
  • Detect unnecessary abstractions and over-parameterized APIs to simplify maintenance.
  • Highlight complex control flow and channel/goroutine patterns that add cognitive load.
  • Use case: When preparing for refactors to reduce complexity before merging.

Quick Start

Run a code audit on your Go project to surface complexity hotspots and deduplication opportunities.

Frequently Asked Questions about simplicity-hunter-go

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

FAQPage Schema
How do I reduce Go code complexity before a refactor?

To reduce Go code complexity, audit your project to identify duplication, dead code paths, and over-parameterized APIs. The audit prescribes behavior-preserving simplifications like inlining trivial wrappers and applying guard clauses.

What causes unnecessary structural complexity in Go concurrency?

Unnecessary structural complexity in Go concurrency stems from channel misuse and goroutine overuse. Auditing these patterns highlights cognitive load, prescribing the simplest shape that preserves intended behavior.

Can I detect interface pollution and mixed concerns in Go projects?

Yes, you can detect interface pollution and mixed concerns by running a structural code audit. It surfaces these specific complexity hotspots alongside deep nesting to simplify maintenance.

What is the best way to find duplication across Go packages and tests?

The best way to find duplication across Go packages and tests is a structural audit. It identifies duplicated logic across functions and tests, prescribing inlining trivial wrappers to deduplicate.

Does this Go code audit remove dead logic paths automatically?

The Go code audit detects dead logic paths and prescribes behavior-preserving simplifications. It prioritizes removing redundant abstractions and applying guard clauses to reduce structural complexity.