grug-brain-development

Review code and architecture for unnecessary complexity and premature abstraction.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps you simplify software decisions and code by fighting unnecessary complexity, premature abstraction, and scattered logic that makes maintenance and debugging painful.

Core Features & Use Cases

  • Code review for complexity: Use it when you suspect over-engineering, clever but confusing abstractions, or “too many layers” that obscure what the code actually does.
  • Architecture decision guidance: Use it to choose simple, concrete designs (often “monolith first”), and to identify natural cut points only after real patterns emerge.
  • Refactoring principles to reduce mental load: Apply locality of behavior, keep expressions debuggable, respect existing code as “Chesterton’s fence,” and keep refactors small so the system stays working.

Use Case Examples

  • You’re reviewing a PR that introduces multiple layers of generic types and interfaces for a problem that only has one or two real use cases.
  • You need to refactor a feature where one button click now requires jumping across many files and concepts to understand behavior.
  • You’re deciding whether to extract services, build reusable frameworks, or keep a simple 80/20 implementation until more evidence exists.

Quick Start

Use the grug-brain-development skill when you are looking to simplify code or reduce complexity so the solution is easier to debug and maintain.

Frequently Asked Questions about grug-brain-development

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

FAQPage Schema
How do I reduce software complexity during code review?

To reduce software complexity during code review, look for premature abstraction and scattered logic. Enforce principles like keeping locality of behavior and saying no to heavy patterns that obscure what the code actually does.

What's the best way to refactor code without breaking existing correctness?

The best way to refactor safely is to keep changes small and respect existing code as Chesterton's fence. Maintain locality of behavior so the system stays working and debuggable while you simplify expressions.

When do I need to extract microservices or build reusable frameworks?

You should only extract services or build frameworks after real patterns emerge from evidence. Design for common cases first and keep a simple 80/20 implementation until proof exists.

Why does over-engineering make debugging painful?

Over-engineering makes debugging painful because jumping across many files and generic layers obscures behavior. Keeping locality of behavior ensures expressions remain debuggable and reduces mental load.

Does this approach work for architecture decisions on monoliths?

Yes, this approach works for architecture decisions by promoting simple concrete designs like monolith first. It helps identify natural cut points only after real patterns emerge.

When should I not use premature abstraction in refactoring?

You should not use premature abstraction when a problem only has one or two real use cases. Avoid multiple layers of generic types and interfaces to keep implementations debuggable.