skills.rest
NavarrePratt
NavarrePrattCOMMUNITY
Explore all skills by this author →
GitHub

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
One-click install
npx skills add https://github.com/NavarrePratt/claude-settings --skill grug-review
Or copy as Structured Prompt for Agent▼
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.

Related Skills

Explore More Software Engineering Skills→
YaroslavKomarovYaroslavKomarov

ai-factory.review

Review staged diffs or pull requests and output a Markdown summary.

Community
Intermediate
togswrtogswr

safe-refactoring

Plan incremental refactoring of legacy code using Tidy First? and Branch by Abstraction.

Community
Advanced
skanehiraskanehira
88

developing

Implements features and fixes bugs using test-driven development with RED→GREEN→REFACTOR cycles.

Community
Advanced
simplerick0simplerick0

quality-review

Identify and document code quality issues during PR reviews.

Community
Basic