principle-minimize-reader-load

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

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Code that is hard to trace forces readers to hold too much context in their heads, slowing down maintenance and increasing the risk of bugs. This Skill gives you a concrete framework for measuring and reducing the cognitive load your code imposes on anyone who reads it. ## Core Features & Use Cases - Layer Auditing: Counts the indirections between a question and its answer, then collapses one-caller wrappers, pass-through adapters, and speculative abstractions. - State Scope Reduction: Shrinks mutable state from globals toward module state, fields, locals, and pure functions, favoring derivation over synchronization. - Use Case: During a code review of a service with six layers of adapters and scattered mutable fields, apply this Skill to inline single-caller wrappers, demand interface compression, and name invariants at boundaries so a new reader can trace any value in under 30 seconds. ## Quick Start Ask the AI to review this module using the minimize reader load principle and identify layers and state that should be collapsed.

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 make code easier to read and trace?

Count the layers between a question and its answer, then collapse wrappers with one caller and adapters with no second implementation. Also shrink mutable state scope, preferring pure functions and locals over fields and globals.

How to reduce indirection in a codebase during code review?

Inline pass-through layers that repeat the same methods and arguments, and demand that interfaces hide meaningful decisions rather than expose broad surfaces. A layer must reduce reader load elsewhere by at least as much as it adds.

When should I keep an abstraction layer instead of inlining it?

Keep a layer when it changes the abstraction, hides meaningful decisions, or serves multiple callers or implementations. Remove it when it has one caller, one implementation, or exists only for a hypothetical future need.

What is the difference between cyclomatic complexity and reader load?

Cyclomatic complexity counts code paths, while reader load measures the work a human does to understand code across two axes: layers to trace and hidden state to hold. A flat file with 50 globals can be as hard to reason about as a deep adapter stack.

How do I reduce mutable state in a module?

Move state down the scope ladder: prefer pure function returns over mutations, locals over fields, fields over module state, and module state over globals. Derive values instead of synchronizing duplicated state.