reducer

Reduce whole-system complexity while preserving behavior and non-functional guarantees.

3|Updated Nov 8, 2014
One-click install
npx skills add https://github.com/mintuz/.dotfiles --skill reducer-mintuz
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: reducer
Source: https://github.com/mintuz/.dotfiles/tree/main/agents/.agents/skills/reducer
Command: npx skills add https://github.com/mintuz/.dotfiles --skill reducer-mintuz

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Systems accumulate branches, state, dependencies, layers, and moving parts over time, and naive simplification attempts often just relocate complexity or silently break behavior. This Skill provides a disciplined method to derive the minimum mechanism from first principles and prove that behavior and guarantees are conserved. ## Core Features & Use Cases - Behavior Conservation Ledger: Inventory every supported behavior, guarantee, and boundary with preservation evidence or explicit proof gaps before making changes. - Whole-System Complexity Baseline: Count control flow, state spaces, structure, and operational dimensions with consistent scope and method before and after reduction. - Reversible Slice Selection: Rank reduction candidates by mechanism removed, confidence, and blast radius, then implement the smallest reversible slice with behavior and mechanism gates. - Use Case: A service has grown to five layers of adapters, three feature flags, and duplicated retry policies. Use this Skill to baseline the mechanism, derive the minimum design, and remove one complete mechanism per slice while proving outputs, errors, and ordering stay identical. ## Quick Start Use the reducer skill to simplify this feature from first principles while preserving behavior and non-functional guarantees.

Frequently Asked Questions about reducer

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

FAQPage Schema
How do I reduce code complexity without changing behavior?

Build a behavior ledger covering outputs, side effects, errors, and ordering, then baseline the whole mechanism across control, state, structure, and operations. Remove one complete mechanism per reversible slice and re-run all affected oracles to prove conservation.

What is the difference between reducing and relocating complexity?

Reduction shrinks the total mechanism counted across the whole system, while relocation moves branches, state, or failure modes across a boundary. The Skill requires before/after counts with identical scope and method, treating net-neutral or displaced results as unfinished.

When should I not use a complexity reduction approach?

Do not use it for functionality cuts or unproven rewrites. Removing supported behavior is a scope change requiring a recorded owner decision, and it must be reported separately from mechanism reduction.

How do I safely delete feature flags and fallback paths?

Confirm the paths are unsupported or superseded, capture characterization tests or pre-change evidence for affected behaviors, then delete in a reversible slice. Before removing a bound, timeout, or back-pressure control, prove another control still enforces its guarantee.

Why does simplification sometimes increase system complexity?

Local simplifications can increase coupling, coordination, or failure modes elsewhere, and renaming, splitting, or wrapping only conceals complexity. The mechanism gate recounts baseline dimensions and inspects downstream owners to detect exported decisions and state.