go-lintbrush

Run a full architecture review — conformance, dependency topology, coupling metrics, API surface audit, and structural findings.

Generate a report of Go file sizes with tier classification (green/yellow/red) and split recommendations.

Fix mechanical Go lint issues (godot, goconst, simple revive violations). For complexity issues, use the refactor agent instead.

Simplify Go code by removing unnecessary complexity

Assess Go codebase architecture and modular integrity using snipe index, go-arch-lint, and SQL-based metrics. Produces a structured report with dependency topology, coupling metrics, API surface audit, and conformance analysis. <example> Context: User wants a top-down architecture health check user: "How healthy is our architecture? Are there layering violations?" assistant: "I'll use the arch-review agent to run a full architecture assessment." </example> <example> Context: User suspects coupling problems user: "Which packages are too tightly coupled?" assistant: "Let me run the arch-review agent to compute coupling metrics across all packages." </example> <example> Context: User wants to check conformance before a release user: "Are we conforming to our architecture rules?" assistant: "I'll run the arch-review agent's conformance phase against both the enforced and target configs." </example>

Analyze duplicate Go code from jscpd reports and propose consolidation strategies. Use when mage qa shows code clones that need consolidation. <example> Context: User runs mage qa and sees code duplication warnings user: "mage qa shows 15 code clones, help me consolidate them" assistant: "I'll use the go-dedup agent to analyze the clones and propose consolidation." </example> <example> Context: User notices similar code across files user: "These two handlers have nearly identical validation logic" assistant: "Let me analyze these with go-dedup to find the best consolidation approach." </example>

Plan and execute strategic Go file splits while maintaining package cohesion. Use when a file exceeds size thresholds and needs reorganization. <example> Context: User has a file in the red zone from mage qa user: "tslsp_handler.go is 2500 lines, help me split it" assistant: "I'll use the go-file-split agent to analyze the file and plan an appropriate split." </example> <example> Context: User wants to reorganize a growing file user: "store.go keeps growing, should I split it?" assistant: "Let me analyze the file structure with go-file-split to recommend the best approach." </example>

Refactor complex Go code to reduce gocyclo/funlen/cyclop/nestif violations while preserving exact behavior. Use when lint reports complexity issues. <example> Context: User runs mage qa and gets gocyclo warnings user: "mage qa is failing with gocyclo issues on handleRequest in server.go" assistant: "I'll use the go-lintbrush refactor agent to reduce the complexity." </example> <example> Context: User wants to clean up a complex function user: "This function is 150 lines and hard to follow. Can you refactor it?" assistant: "Let me use the go-lintbrush refactor agent to split this into cleaner units." </example> <example> Context: golangci-lint reports nestif violations user: "I'm getting nestif warnings about deep nesting in processData" assistant: "I'll apply guard clause patterns to flatten the nesting." </example>

Simplify Go code by removing unnecessary abstraction, dead code, and over-engineering. Use when code works but feels more complex than needed. <example> Context: User feels code is over-engineered user: "This file has interfaces for everything but only one implementation of each" assistant: "I'll use the go-code-simplify agent to identify and remove unnecessary abstractions." </example> <example> Context: User wants cleaner code user: "Can you simplify this? It works but feels bloated" assistant: "Let me use the go-code-simplify agent to find what can be removed or consolidated." </example> <example> Context: Code review reveals complexity user: "The PR has too many layers. Can you flatten it?" assistant: "I'll analyze with the go-code-simplify agent to identify removable indirection." </example>

This skill should be used when the user asks about "architecture review", "dependency graph", "coupling", "cohesion", "instability", "afferent", "efferent", "layering violation", "package boundaries", "API surface", "god package", "orphan package", "modular integrity", or needs guidance on assessing Go codebase architecture health. Provides metrics, thresholds, and snipe SQL queries for architecture analysis.

This skill should be used when the user asks about "gocyclo", "funlen", "cyclop", "nestif", "cognitive complexity", "refactor long function", "reduce nesting", "complexity reduction", or needs guidance on simplifying complex Go code. Provides patterns and techniques for reducing Go code complexity while preserving behavior.

This skill should be used when the user asks about "code duplication", "jscpd", "DRY principle", "duplicate code", "clone detection", "code consolidation", or needs guidance on when and how to consolidate duplicate Go code.

This skill should be used when the user asks about "file size", "large file", "split file", "file too long", "LOC limit", "organize Go files", or needs guidance on when and how to split large Go source files.

This skill should be used when the user asks about "simplify code", "over-abstraction", "dead code", "premature generics", "unused interface", "unnecessary complexity", "go idioms", or needs guidance on simplifying Go code beyond lint violations. Provides patterns for removing accidental complexity while preserving behavior.