grug-review

Review code changes for unnecessary complexity using a checklist-driven approach.

2|2|Updated Dec 30, 2025

Search Tags:#refactoring #readability #maintainability #complexity #code-review #premature-abstraction #grug-brain

Ready to run

npx skills add https://github.com/NavarrePratt/claude-settings --skill grug-review

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: grug-review
Source: https://github.com/NavarrePratt/claude-settings/tree/main/skills/grug-review
Command: npx skills add https://github.com/NavarrePratt/claude-settings --skill grug-review

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Grug-review tackles the natural tendency to overlook unnecessary complexity in code changes by providing a principled, anti-complexity lens for PR reviews.

Core Features & Use Cases

Complexity check: flags added layers of abstraction or unnecessary logic.
Abstraction smell: identifies premature abstractions before necessity emerges.
Locality and cut points: evaluates if changes keep related code together and choose natural refactor points.
Readability over cleverness: prioritizes maintainable, explicit code over clever tricks.
Guardrails for refactoring: supports safe, incremental improvements during reviews.

Quick Start

Review the latest PR using the grug-brain checklist to identify unnecessary complexity.

Frequently Asked Questions about grug-review

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

FAQPage Schema

How do I review code changes to reduce unnecessary complexity in pull requests?▼

To review code changes and reduce unnecessary complexity, apply a deterministic, checklist-driven lens to pull requests that flags added layers of abstraction and enforces readability over cleverness.

What is premature abstraction and how do I identify it during a code review?▼

Premature abstraction introduces unnecessary logic before necessity emerges. Identify it during code review by checking for abstraction smells and evaluating if changes maintain local cohesion and natural refactor points.

How do I perform a readability-focused PR review across different programming languages?▼

Perform a readability-focused PR review across languages by applying a consistent, anti-complexity checklist that evaluates maintainability, prioritizes explicit code over clever tricks, and identifies structural cut points.

What is the best way to safely refactor code while reviewing a diff?▼

The best way to safely refactor code while reviewing a diff is to enforce guardrails for incremental improvements, ensuring changes keep related code together and choose natural refactor points to maintain stability.

Does this complexity checklist approach work for any programming language?▼

Yes, this complexity checklist approach works across languages because it focuses on universal structural issues like abstraction smells, local cohesion, and cut points rather than language-specific syntax.

When should I avoid refactoring during a code review?▼

Avoid refactoring during a code review when changes lack natural cut points or when incremental improvements cannot be safely applied without breaking local cohesion and existing readability.