reduce-system-complexity

Reduce mechanism in a selected system while conserving observable behavior and guarantees.

723|93|Updated Nov 14, 2021
One-click install
npx skills add https://github.com/citypaul/.dotfiles --skill reduce-system-complexity
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: reduce-system-complexity
Source: https://github.com/citypaul/.dotfiles/tree/main/claude/.claude/skills/reduce-system-complexity
Command: npx skills add https://github.com/citypaul/.dotfiles --skill reduce-system-complexity

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Software systems accumulate branches, states, flags, layers, and operational machinery that increase maintenance cost. This Skill provides a disciplined workflow to remove that mechanism while proving that observable behavior and non-functional guarantees are preserved, rather than merely relocated or hidden.

Core Features & Use Cases

  • Behavior Conservation Ledger: Classifies documented contracts, relied-upon behavior, disputed bugs, and obsolete internals, then tracks preservation evidence and fidelity gaps for each.
  • Whole-Mechanism Accounting: Baselines control flow, state and time, structure, and operational variability across the full path, then recounts the same dimensions after the change to prove net removal.
  • Gated Reduction Slices: Separates behavior and mechanism gates, distinguishing reduction transitions from terminal reductions so partial progress never claims a finished reduction.
  • Use Case: A service has three retry layers, two feature flags, and a legacy adapter chain. Use this Skill to diagnose the minimum mechanism justified by real constraints, then execute an authorized slice that deletes the superseded machinery with evidence.

Quick Start

Use the reduce-system-complexity skill to diagnose the checkout payment path and propose a reduction that removes the legacy retry and flag machinery while preserving its documented behavior.

Frequently Asked Questions about reduce-system-complexity

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

FAQPage Schema
How do I reduce complexity in a codebase without breaking behavior?

Select a concrete behavior path, inventory its outputs, effects, and guarantees in a conservation ledger, then derive a minimum mechanism from real constraints. Execute small reversible slices and pass separate behavior and mechanism gates before claiming any reduction.

What is the difference between refactoring and system complexity reduction?

Routine refactoring performs bounded behavior-preserving cleanup, while complexity reduction requires whole-path mechanism accounting and proof of net removal. A change that merely renames, splits, or relocates complexity fails the mechanism gate.

When should I not use a complexity reduction workflow?

Avoid it for routine cleanup, new behavior, functionality cuts, speculative rewrites, or architecture candidate discovery. It also does not apply to Redux or functional reducer functions despite the similar name.

Can a reduction temporarily add mechanism during a migration?

Yes, expand/contract migrations may add a bridge, flag, or dual write as a reduction transition. Each bridge needs an owner, removal condition, and bounded lifetime, and no net-reduction claim is allowed until the terminal slice removes it.

How is behavior preservation verified during a reduction?

Preservation relies on passing behavior-level tests, characterisation tests, and proportionate reachability, contract, integration, and operational evidence. Results are reported as calibrated evidence with explicit fidelity gaps, never as proof of universal equivalence.