review-simplicity

Audit codebases for unnecessary complexity and premature abstractions.

4|1|Updated Jan 11, 2026
One-click install
npx skills add https://github.com/doodledood/codex-workflow --skill review-simplicity
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: review-simplicity
Source: https://github.com/doodledood/codex-workflow/tree/main/skills/review-simplicity
Command: npx skills add https://github.com/doodledood/codex-workflow --skill review-simplicity

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Audit code for unnecessary complexity, over-engineering, and premature abstractions to reduce cognitive load and maintenance effort.

Core Features & Use Cases

  • Read-only analysis that surfaces anti-patterns like speculative generality, YAGNI violations, and over-parameterized interfaces.
  • Scope-aware reviews based on explicit file paths or diffs against origin/main, delivering actionable simplification recommendations.
  • Structured reporting that guides engineers toward simpler, maintainable code across teams.

Quick Start

Provide the specific files or scope to begin a read-only simplification review.

Frequently Asked Questions about review-simplicity

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

FAQPage Schema
How do I spot over-engineering and unnecessary complexity in my codebase?

To spot over-engineering in your codebase, audit your code for speculative generality, YAGNI violations, and premature abstractions. This read-only analysis evaluates specific files or directory diffs to surface anti-patterns and reduce cognitive load.

What is premature abstraction and how does it impact code maintainability?

Premature abstraction occurs when code is built for speculative future needs rather than current requirements, negatively impacting maintainability. Structured complexity assessment identifies these YAGNI violations, guiding engineers toward simpler, maintainable code without altering functionality.

Can I review diffs against origin/main to check for YAGNI violations?

Yes, you can review diffs against origin/main to check for YAGNI violations. This scope-aware analysis focuses the complexity assessment exclusively on relevant changes, delivering actionable simplification recommendations for the newly written code.

How do I analyze over-parameterized interfaces without modifying functionality?

You can analyze over-parameterized interfaces without modifying functionality by running a read-only simplification review. This process enforces structured evaluation across context gathering and complexity assessment to provide actionable simplification recommendations.

Does this code review process work on explicitly specified files and directories?

Yes, this code review process works on explicitly specified files and directories. By providing the specific file paths or scope, the analysis enforces structured evaluation to identify unnecessary complexity and over-engineering across the targeted codebase.

When should I not use automated simplification recommendations?

You should not expect automated simplification recommendations to modify your functionality. This analysis is strictly read-only, meaning it surfaces anti-patterns and guides engineers toward simpler code structures without directly executing refactoring changes.