principle-laziness-protocol

Guides refactoring decisions toward deletion and minimal diffs over added abstractions.

Updated Mar 27, 2026
One-click install
npx skills add https://github.com/gmackie/agent-skills --skill principle-laziness-protocol-gmackie
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: principle-laziness-protocol
Source: https://github.com/gmackie/agent-skills/tree/main/skills/principle-laziness-protocol
Command: npx skills add https://github.com/gmackie/agent-skills --skill principle-laziness-protocol-gmackie

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? AI coding agents write code cheaply, which makes over-engineering easy: unnecessary abstractions, deep call chains, and bloated diffs. This Skill counteracts that tendency by applying a human maintainer's fatigue as a design constraint, keeping changes small and codebases simple. ## Core Features & Use Cases - Deletion-first refactoring: Prioritizes removing code over adding new layers when asked to improve or refactor. - Flat call hierarchy enforcement: Flags designs where answering a question requires tracing through more than 3 files or layers. - Decision consolidation: Detects repeated choices scattered across the codebase and moves them behind a single source of truth. - Use Case: When asked to thread a new signal through types, schemas, and pipelines, the Skill prompts a stop-and-reconsider check for a more direct path before writing any code. ## Quick Start Ask the agent to refactor this module while following the laziness protocol, preferring deletions and the smallest possible diff.

Frequently Asked Questions about principle-laziness-protocol

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

FAQPage Schema
How do I prevent an AI coding agent from over-engineering refactors?▼

Apply a laziness protocol that biases toward deletion and the smallest diff that solves the problem. It instructs the agent to look for removals before additions and to question any new abstraction or layer before writing code.

How to reduce diff size during code refactoring?▼

Reduce diff size by making the smallest change that solves the problem and preferring deletions over additions. Fewer lines beat elegant boilerplate, and tiny pass-throughs or duplicated choices should be removed before they spread.

When should I flatten a deep call hierarchy?▼

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

What are the limitations of a minimal-diff refactoring approach?▼

A minimal-diff approach can defer necessary structural redesign when the existing architecture is fundamentally wrong. It optimizes for maintainability of the current change, not for long-term architectural correctness.

When should I avoid threading a new signal through types and schemas?▼

Stop and look for a more direct path whenever a task asks you to pass a new signal through types, schemas, pipelines, or similar layers. Often the decision can be consolidated behind one source of truth and passed as a simple flag.