principle-minimize-reader-load

Reviews code to reduce indirection layers and hidden mutable state for readers.

Updated Jul 29, 2026
One-click install
npx skills add https://github.com/mmdmcy/fluttAIrbar --skill principle-minimize-reader-load-mmdmcy
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: principle-minimize-reader-load
Source: https://github.com/mmdmcy/fluttAIrbar/tree/main/plugins/pstack/skills/principle-minimize-reader-load
Command: npx skills add https://github.com/mmdmcy/fluttAIrbar --skill principle-minimize-reader-load-mmdmcy

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Code that is hard to trace slows down every future change. This Skill gives reviewers a concrete framework for measuring how much work a reader must do to understand code, counting the layers between a question and its answer and the hidden state a reader must hold in their head. ## Core Features & Use Cases - Layer Auditing: Identifies one-caller wrappers, pass-through adapters, and speculative abstractions that add indirection without compression, and recommends inlining them. - State Scope Reduction: Guides shrinking mutable scope from globals to module state, fields, locals, and pure functions, and deriving values instead of syncing them. - Use Case: During a code review of a service with six adapter layers and scattered mutable fields, apply this Skill to decide which layers to collapse and which state to localize, then verify a new reader can answer "where does X come from?" in under 30 seconds. ## Quick Start Review this module using the minimize reader load principle and tell me which layers or state to cut.

Frequently Asked Questions about principle-minimize-reader-load

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

FAQPage Schema
How do I reduce cognitive load in code reviews?

Measure reader load on two axes: layers of indirection between a question and its answer, and hidden mutable state the reader must track. Collapse wrappers with one caller, inline pass-through adapters, and shrink state scope toward locals and pure functions.

How to decide when to remove an abstraction layer?

Remove a layer when it has only one caller, no second implementation, or merely repeats the same methods and arguments as the layer below. A layer earns its keep only if it compresses complexity or hides a meaningful decision.

What is the difference between reader load and cyclomatic complexity?

Cyclomatic complexity counts branches, while reader load counts indirection layers and hidden state. A flat file with fifty globals can be harder to reason about than a deep call stack, so both axes must be guarded independently.

When should I not collapse a wrapper or adapter?

Keep a layer when it hides a meaningful decision, compresses a broad interface into a narrow one, or genuinely supports multiple implementations. Collapsing boundaries that hide real complexity just moves reader load elsewhere.

How do I reduce mutable state scope in a module?

Prefer returns over mutations, locals over fields, fields over module state, and module state over globals. Derive values instead of syncing them, and name invariants once at the boundary rather than repeating them in every consumer.