principle-laziness-protocol

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

6.6k|542|Updated Jan 23, 2026
One-click install
npx skills add https://github.com/cursor/plugins --skill principle-laziness-protocol
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: principle-laziness-protocol
Source: https://github.com/cursor/plugins/tree/main/pstack/skills/principle-laziness-protocol
Command: npx skills add https://github.com/cursor/plugins --skill principle-laziness-protocol

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

AI coding agents tend to over-engineer: adding layers, threading signals through schemas, and growing diffs when a smaller change would work. This Skill counteracts that bias by applying a maintainer's fatigue standard to every refactoring or design decision.

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: Detects repeated choices scattered across the code and consolidates them behind a single source of truth.
  • Use Case: When asked to pass a new flag through types, schemas, and pipeline layers, the Skill prompts the agent to stop and find a more direct path instead of threading the signal.

Quick Start

Ask the agent to refactor a 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 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 prefer removals over additions and to question any new abstraction or layer before introducing it.

How to reduce diff size during code refactoring?

Minimize the diff by making the smallest change that solves the problem and preferring deletion over new code. Consolidate repeated decisions behind one source of truth instead of threading new signals through multiple layers.

When should I avoid adding abstractions or layers to code?

Avoid new abstractions when answering a question about the code would require tracing through more than 3 files or layers. Also stop when a task asks you to pass a signal through types, schemas, or pipelines and look for a more direct path first.

What is a flat call hierarchy and why does it matter?

A flat call hierarchy avoids deep call chains so behavior can be understood without traversing many files. A rich interface hiding substantial work is acceptable, but coordination spread across many thin pass-through layers compounds maintenance cost.

When is the laziness protocol not the right approach?

It is less suitable when a problem genuinely requires new structure, such as adding a feature with no existing code path to reuse. The protocol targets refactoring and diff evaluation, not greenfield design where some construction is unavoidable.