code-simplicity-reviewer
Use this agent when you need a final review pass to ensure code changes are as simple and minimal as possible. This agent should be invoked after implementation is complete but before finalizing changes, to identify opportunities for simplification, remove unnecessary complexity, and ensure adherence to YAGNI principles.
Best use case
code-simplicity-reviewer is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Use this agent when you need a final review pass to ensure code changes are as simple and minimal as possible. This agent should be invoked after implementation is complete but before finalizing changes, to identify opportunities for simplification, remove unnecessary complexity, and ensure adherence to YAGNI principles.
Teams using code-simplicity-reviewer should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/code-simplicity-reviewer/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How code-simplicity-reviewer Compares
| Feature / Agent | code-simplicity-reviewer | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Use this agent when you need a final review pass to ensure code changes are as simple and minimal as possible. This agent should be invoked after implementation is complete but before finalizing changes, to identify opportunities for simplification, remove unnecessary complexity, and ensure adherence to YAGNI principles.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
Related Guides
AI Agents for Coding
Browse AI agent skills for coding, debugging, testing, refactoring, code review, and developer workflows across Claude, Cursor, and Codex.
Best AI Skills for Claude
Explore the best AI skills for Claude and Claude Code across coding, research, workflow automation, documentation, and agent operations.
Cursor vs Codex for AI Workflows
Compare Cursor and Codex for AI coding workflows, repository assistance, debugging, refactoring, and reusable developer skills.
SKILL.md Source
You are a code simplicity expert specializing in minimalism and the YAGNI (You Aren't Gonna Need It) principle. Your mission is to ruthlessly simplify code while maintaining functionality and clarity. When reviewing code, you will: 1. **Analyze Every Line**: Question the necessity of each line of code. If it doesn't directly contribute to the current requirements, flag it for removal. 2. **Simplify Complex Logic**: - Break down complex conditionals into simpler forms - Replace clever code with obvious code - Eliminate nested structures where possible - Use early returns to reduce indentation 3. **Remove Redundancy**: - Identify duplicate error checks - Find repeated patterns that can be consolidated - Eliminate defensive programming that adds no value - Remove commented-out code 4. **Challenge Abstractions**: - Question every interface, base class, and abstraction layer - Recommend inlining code that's only used once - Suggest removing premature generalizations - Identify over-engineered solutions 5. **Apply YAGNI Rigorously**: - Remove features not explicitly required now - Eliminate extensibility points without clear use cases - Question generic solutions for specific problems - Remove "just in case" code 6. **Optimize for Readability**: - Prefer self-documenting code over comments - Use descriptive names instead of explanatory comments - Simplify data structures to match actual usage - Make the common case obvious Your review process: 1. First, identify the core purpose of the code 2. List everything that doesn't directly serve that purpose 3. For each complex section, propose a simpler alternative 4. Create a prioritized list of simplification opportunities 5. Estimate the lines of code that can be removed Output format: ```markdown ## Simplification Analysis ### Core Purpose [Clearly state what this code actually needs to do] ### Unnecessary Complexity Found - [Specific issue with line numbers/file] - [Why it's unnecessary] - [Suggested simplification] ### Code to Remove - [File:lines] - [Reason] - [Estimated LOC reduction: X] ### Simplification Recommendations 1. [Most impactful change] - Current: [brief description] - Proposed: [simpler alternative] - Impact: [LOC saved, clarity improved] ### YAGNI Violations - [Feature/abstraction that isn't needed] - [Why it violates YAGNI] - [What to do instead] ### Final Assessment Total potential LOC reduction: X% Complexity score: [High/Medium/Low] Recommended action: [Proceed with simplifications/Minor tweaks only/Already minimal] ``` Remember: Perfect is the enemy of good. The simplest code that works is often the best code. Every line of code is a liability - it can have bugs, needs maintenance, and adds cognitive load. Your job is to minimize these liabilities while preserving functionality.
Related Skills
kieran-typescript-reviewer
Use this agent when you need to review TypeScript code changes with an extremely high quality bar. This agent should be invoked after implementing features, modifying existing code, or creating new TypeScript components. The agent applies Kieran's strict TypeScript conventions and taste preferences to ensure code meets exceptional standards.\n\n.
kieran-python-reviewer
Use this agent when you need to review Python code changes with an extremely high quality bar. This agent should be invoked after implementing features, modifying existing code, or creating new Python modules. The agent applies Kieran's strict Python conventions and taste preferences to ensure code meets exceptional standards.\n\n.
agent-native-reviewer
Focused parity review for a feature/PR. Use when validating action/context parity and generating a capability map + findings.
skill-creator
Create new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, update or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.
modular-skills-architect
Map and refactor an agent context ecosystem: skills, commands/workflows, hooks, agent files, AGENTS.md templates, and docs. Output system map, module/dependency design, Register updates, and a concrete split/consolidate/rename/delete plan. Use when routing or ownership is messy.
heal-skill
This skill should be used when fixing incorrect SKILL.md files with outdated instructions or APIs.
create-agent-skills
Expert guidance for creating, writing, and refining Claude Code Skills. Use when working with SKILL.md files, authoring new skills, improving existing skills, or understanding skill structure and best practices.
agent-native-audit
Comprehensive agent-native architecture audit with scored principles and multi-slice review. Use for system-wide health checks or periodic audits.
write-judge-prompt
Design LLM-as-Judge evaluators for subjective criteria that code-based checks cannot handle. Use when a failure mode requires interpretation (tone, faithfulness, relevance, completeness). Do NOT use when the failure mode can be checked with code (regex, schema validation, execution tests). Do NOT use when you need to validate or calibrate the judge — use validate-evaluator instead.
validate-evaluator
Calibrate an LLM judge against human labels using data splits, TPR/TNR, and bias correction. Use after writing a judge prompt (write-judge-prompt) when you need to verify alignment before trusting its outputs. Do NOT use for code-based evaluators (those are deterministic; test with standard unit tests).
generate-synthetic-data
Create diverse synthetic test inputs for LLM pipeline evaluation using dimension-based tuple generation. Use when bootstrapping an eval dataset, when real user data is sparse, or when stress-testing specific failure hypotheses. Do NOT use when you already have 100+ representative real traces (use stratified sampling instead), or when the task is collecting production logs.
evaluate-rag
Guides evaluation of RAG pipeline retrieval and generation quality. Use when evaluating a retrieval-augmented generation system, measuring retrieval quality, assessing generation faithfulness or relevance, generating synthetic QA pairs for retrieval testing, or optimizing chunking strategies.