simplification-cascades
Find one insight that eliminates multiple components - "if this is true, we don't need X, Y, or Z"
When & Why to Use This Skill
Simplification Cascades is a strategic Claude skill designed for radical complexity reduction in software systems. It helps architects and developers identify 'unifying principles'—singular insights that collapse multiple redundant components, special cases, and fragmented logic into elegant, maintainable abstractions. By focusing on the '10x win' rather than incremental improvements, this skill enables the deletion of unnecessary code and the creation of more robust, scalable system designs.
Use Cases
- Refactoring Fragmented Logic: Consolidating multiple similar implementations (e.g., different handlers for batch, real-time, and file data) into a single, unified abstraction like a Stream Processor.
- Eliminating Configuration Bloat: Identifying universal defaults that satisfy the vast majority of use cases to remove excessive and confusing configuration options.
- Streamlining Resource Governance: Replacing separate systems for rate limiting, session tracking, and connection pooling with a generalized Resource Governor pattern.
- Simplifying Rule Engines: Finding a general rule without exceptions to replace a growing list of special-case handlers and complex conditional branches.
- Reducing Technical Debt: Systematically identifying 'whack-a-mole' refactoring patterns and replacing them with a domain-independent pattern that solves the root complexity.
| name | simplification-cascades |
|---|---|
| description | Find one insight that eliminates multiple components - "if this is true, we don't need X, Y, or Z" |
| when_to_use | when implementing the same concept multiple ways, accumulating special cases, or complexity is spiraling |
| version | 1.1.0 |
Simplification Cascades
Overview
Sometimes one insight eliminates 10 things. Look for the unifying principle that makes multiple components unnecessary.
Core principle: "Everything is a special case of..." collapses complexity dramatically.
Quick Reference
| Symptom | Likely Cascade |
|---|---|
| Same thing implemented 5+ ways | Abstract the common pattern |
| Growing special case list | Find the general case |
| Complex rules with exceptions | Find the rule that has no exceptions |
| Excessive config options | Find defaults that work for 95% |
The Pattern
Look for:
- Multiple implementations of similar concepts
- Special case handling everywhere
- "We need to handle A, B, C, D differently..."
- Complex rules with many exceptions
Ask: "What if they're all the same thing underneath?"
Examples
Cascade 1: Stream Abstraction
Before: Separate handlers for batch/real-time/file/network data Insight: "All inputs are streams - just different sources" After: One stream processor, multiple stream sources Eliminated: 4 separate implementations
Cascade 2: Resource Governance
Before: Session tracking, rate limiting, file validation, connection pooling (all separate) Insight: "All are per-entity resource limits" After: One ResourceGovernor with 4 resource types Eliminated: 4 custom enforcement systems
Cascade 3: Immutability
Before: Defensive copying, locking, cache invalidation, temporal coupling Insight: "Treat everything as immutable data + transformations" After: Functional programming patterns Eliminated: Entire classes of synchronization problems
Process
- List the variations - What's implemented multiple ways?
- Find the essence - What's the same underneath?
- Extract abstraction - What's the domain-independent pattern?
- Test it - Do all cases fit cleanly?
- Measure cascade - How many things become unnecessary?
Red Flags You're Missing a Cascade
- "We just need to add one more case..." (repeating forever)
- "These are all similar but different" (maybe they're the same?)
- Refactoring feels like whack-a-mole (fix one, break another)
- Growing configuration file
- "Don't touch that, it's complicated" (complexity hiding pattern)
Remember
- Simplification cascades = 10x wins, not 10% improvements
- One powerful abstraction > ten clever hacks
- The pattern is usually already there, just needs recognition
- Measure in "how many things can we delete?"