principle-laziness-protocol

Guides refactoring decisions toward deletion, minimal diffs, and flat call hierarchies.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? AI-assisted coding tends to over-engineer: adding abstractions, layers, and signal threading when a smaller change would do. This Skill counteracts that bias by applying a maintainer's discipline of preferring deletion and the smallest viable change. ## Core Features & Use Cases - Deletion-first refactoring: Prioritizes removing code over adding new abstractions when improving a codebase. - Flat call hierarchy enforcement: Flags designs where answering a question requires tracing through more than 3 files or layers. - Decision consolidation: Pushes repeated choices behind a single source of truth passed as a simple flag. - Use Case: When asked to thread a new signal through types, schemas, and pipelines, the Skill stops and looks for a more direct path instead of propagating the change across layers. ## Quick Start Ask the AI to refactor this module while applying the laziness protocol, preferring deletions and the smallest diff that solves the problem.

Frequently Asked Questions about principle-laziness-protocol

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

FAQPage Schema
How do I avoid over-engineering when refactoring code?

Prefer deletion over addition, make the smallest change that solves the problem, and question any task that threads a new signal through multiple layers. If a human maintainer would find the result exhausting, simplify it.

How to reduce diff size in a code refactor?

Look for removals before additions, consolidate repeated decisions behind one source of truth passed as a simple flag, and avoid elegant boilerplate. Fewer lines that solve the problem beat larger structural rewrites.

When should I flatten a deep call hierarchy?

Flatten when answering a question about the code requires tracing through more than 3 files or layers. A rich interface hiding substantial work is acceptable; long chains of pass-through calls are not.

When is adding an abstraction layer the wrong choice?

It is wrong when it only passes data through, duplicates a decision made elsewhere, or leaks a representation across boundaries. Small pass-throughs compound into permanent coordination costs and should be removed early.

Does this refactoring approach work for large legacy codebases?

Yes, the principles are scale-independent: minimize each diff, remove tiny leaks before they spread, and keep call hierarchies flat. Apply them incrementally per change rather than attempting a wholesale rewrite.