arib-dev-lean

Analyze source code and git diffs to report over-engineering and unnecessary abstraction.

2|Updated Apr 19, 2026
One-click install
npx skills add https://github.com/AribSudia/claude-code-methodology --skill arib-dev-lean
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: arib-dev-lean
Source: https://github.com/AribSudia/claude-code-methodology/tree/main/.claude/skills/arib-dev-lean
Command: npx skills add https://github.com/AribSudia/claude-code-methodology --skill arib-dev-lean

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill addresses the accumulation of technical debt and over-engineering by identifying unnecessary abstractions, speculative configurations, and dead code paths that complicate maintenance.

Core Features & Use Cases

  • YAGNI Review: Systematically flags single-use abstractions, premature generalizations, and unused parameters.
  • Advisory Reporting: Generates a structured delete-list and watch-list for developer review without performing destructive actions.
  • Use Case: Run this review on a legacy module to identify and inline single-use interfaces or remove speculative feature flags that are no longer serving the codebase.

Quick Start

Use the arib-dev-lean skill to review the current module for over-engineering and generate a report.

Frequently Asked Questions about arib-dev-lean

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

FAQPage Schema
How do I identify over-engineering and unnecessary abstractions in my codebase?

You can identify over-engineering by analyzing source code modules and git diffs to apply a YAGNI-based complexity ladder, which flags unnecessary abstractions and dead code paths while preserving essential framework ceremony and security guards.

What is the best way to review legacy code for technical debt and speculative features?

Reviewing legacy code for technical debt is best handled by generating a non-destructive advisory report categorizing findings into delete-lists and watch-lists, flagging speculative configurations and unused parameters for developer verification.

How do I prune code bloat without breaking framework ceremony or security guards?

Pruning code bloat without breaking framework ceremony or security guards requires applying a YAGNI-based review that explicitly preserves essential structures, outputting a non-destructive advisory report with delete-lists and watch-lists for manual verification.

Does YAGNI code review automatically delete dead code paths and unused parameters?

YAGNI code review does not automatically delete dead code paths; it operates non-destructively by producing an advisory report with delete-lists and watch-lists, requiring developer verification before any code deletion occurs.

Can I analyze git diffs to find single-use abstractions and premature generalizations?

You can analyze git diffs to find single-use abstractions and premature generalizations by applying a YAGNI-based complexity ladder to the changes, flagging over-engineering instances in a structured advisory report for developer review.

When should I avoid using a YAGNI-based complexity ladder for code review?

Avoid using a YAGNI-based complexity ladder when code heavily relies on complex framework ceremony or security guards that could be misinterpreted as bloat, though the non-destructive advisory report ensures limitations only impact manual verification workload.