Loading...
Loading...
Found 8 Skills
Final review pass to ensure code is as simple and minimal as possible. Use after implementation is complete to identify YAGNI violations and simplification opportunities.
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. Examples: <example>Context: The user has just implemented a new feature and wants to ensure it's as simple as possible. user: "I've finished implementing the user authentication system" assistant: "Great! Let me review the implementation for simplicity and minimalism using the code-simplicity-reviewer agent" <commentary>Since implementation is complete, use the code-simplicity-reviewer agent to identify simplification opportunities.</commentary></example> <example>Context: The user has written complex business logic and wants to simplify it. user: "I think this order processing logic might be overly complex" assistant: "I'll use the code-simplicity-reviewer agent to analyze the complexity...
Use when designing solutions, adding features, or refactoring by applying KISS, YAGNI, and Principle of Least Astonishment to write simple, predictable code.
Use when tempted to write clever code. Use when solution feels complex. Use when showing off skills instead of solving problems.
Audit code for over-engineering, premature optimization, and cognitive complexity. Identifies unnecessary abstractions, YAGNI violations, and overly complex solutions. Read-only analysis. Triggers: review simplicity, over-engineering, complexity check, YAGNI.
Before adding abstraction, asks "do we need this now?" Activates when proposing factories, abstract classes, config-driven behavior, or "for future extensibility." Resists over-engineering. Three similar lines are better than a premature abstraction.
The practice of restructuring and simplifying code continuously – reducing complexity, improving design, and keeping codebases clean.
Ruthless complexity killer. Challenges every abstraction, layer, and pattern with "can you do this with 1/10th the complexity?" Roasts over-engineering and forces the simplest solution that works.