lean-build

Implements narrow feature slices with explicit scope, acceptance criteria, and stop conditions.

Updated Aug 20, 2026
One-click install
npx skills add https://github.com/bittlinkm/claude-setup --skill lean-build-bittlinkm
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: lean-build
Source: https://github.com/bittlinkm/claude-setup/tree/main/skills/lean-build
Command: npx skills add https://github.com/bittlinkm/claude-setup --skill lean-build-bittlinkm

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Feature work often balloons into over-engineered implementations with speculative modes, providers, and configuration that nobody asked for. This Skill constrains AI-driven development to the smallest coherent end-to-end slice that satisfies observable acceptance criteria. ## Core Features & Use Cases - Scope Discipline: Derives explicit acceptance criteria and non-goals from the request and repository before writing code. - Architecture-First Delivery: Traces the entry point through the layers that own invariants, delivering a coherent path across responsible layers rather than a local patch. - Reuse and Refactor Judgment: Reuses fitting seams and refactors only when patching would duplicate behavior, weaken ownership, or hide root causes. - Use Case: When adding a new API endpoint to an existing service, use this Skill to implement only the required path through routing, domain, and persistence layers, skipping speculative config, providers, and polish. ## Quick Start Use lean-build to implement this feature with strict scope and an explicit stop condition.

Frequently Asked Questions about lean-build

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

FAQPage Schema
How do I prevent AI from overbuilding a feature?

Define observable acceptance criteria and explicit non-goals before implementation, then stop when acceptance passes. This Skill enforces that workflow by deriving scope from the request and repository and omitting modes, providers, and polish unless acceptance requires them.

How to implement a feature across multiple layers without patching?

Trace the entry point through the layers that own invariants and deliver a coherent end-to-end path across them. Avoid forcing work into one file or a local patch, and refactor only when patching duplicates behavior or hides root causes.

When should I add new config, services, or migrations?

Add surface area, dependencies, services, config, or migrations only when lifecycle design or acceptance criteria require them. When you do add one, state the material tradeoff explicitly so the cost is visible.

When is lean-build not the right approach?

It is not suited for exploratory prototypes, greenfield architecture design, or work where broad extensibility is itself the requirement. It targets bounded feature slices in existing systems with identifiable acceptance criteria.

What does the skill report when implementation finishes?

It reports only material omissions and the trigger that would require them, after running a focused proof that acceptance passes. The work is kept runnable and Core safety is preserved throughout.