Skill

Simplification Cascades

Find one insight that eliminates multiple components - "if this is true, we don't need X, Y, or Z"

Install

npx claudepluginhub orban/claude-skills --plugin claude-skills

Tool Access

This skill uses the workspace's default tool permissions.

Preview

Sometimes one insight eliminates 10 things. Look for the unifying principle that makes multiple components unnecessary.

SKILL.md

Similar Skills

using-git-worktrees

Creates isolated Git worktrees for feature branches with prioritized directory selection, gitignore safety checks, auto project setup for Node/Python/Rust/Go, and baseline verification.

superpowers

169.2k

subagent-driven-development

3 files

Executes implementation plans in current session by dispatching fresh subagents per independent task, with two-stage reviews: spec compliance then code quality.

superpowers

169.2k

dispatching-parallel-agents

Dispatches parallel agents to independently tackle 2+ tasks like separate test failures or subsystems without shared state or dependencies.

superpowers

169.2k

Stats

Parent Repo Stars0

Parent Repo Forks0

Last CommitJan 24, 2026

Used By5 plugins

Actions

View Source View Plugin View on GitHub View README

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?"