Catalog
juliusbrussee/lean-build

juliusbrussee

lean-build

Build feature work with high overbuilding risk. Use for new behavior, product slices, or integrations where repository reuse, strict scope, and an explicit stop condition matter.

v1.0Latest
New~263Updated Aug 17, 2026

Lean build

Native Core's architecture-first simplicity remains mandatory. Turn feature into complete narrow outcome fitting system.

  • Derive observable acceptance and explicit non-goals from request and repository.
  • Trace entry point through layers owning invariants.
  • Deliver coherent end-to-end path across responsible layers; never force work into one file, direct expression, or local patch.
  • Reuse fitting seam. Refactor when patching duplicates behavior, weakens ownership, or hides root cause.
  • Omit modes, providers, config, extensibility, and polish unless acceptance needs them.
  • Add surface, dependency, service, config, or migration only for lifecycle design or acceptance; state material tradeoff.
  • Keep work runnable; preserve Core safety.

Exercise path. Run focused proof. Stop when acceptance passes. Report only material omissions and trigger.

Files2
2 files · 1.6 KB

Select a file to preview

Overall Score

54/100

Grade

C

Adequate

Safety

75

Quality

42

Clarity

48

Completeness

45

Summary

Lean Build is a code architecture and feature development skill that guides agents to construct minimal, end-to-end feature slices within a system. It emphasizes architecture-first design, layer-aware tracing, and explicit scope constraints to avoid overbuilding and unnecessary complexity.

Detected Capabilities

code analysisarchitectural guidancescope definitionfeature designlayer-aware planning

Trigger Keywords

Phrases that MCP clients use to match this skill to user intent.

build feature sliceminimal coherent workarchitecture-first designscope new featurelayer-aware implementation

Use Cases

  • Implement new product features with strict scope boundaries
  • Design feature work that respects architectural layers and invariants
  • Build integrations that reuse existing system seams
  • Deliver end-to-end feature paths across multiple layers
  • Prevent scope creep and overbuilding in feature development

Quality Notes

  • Instructions are architecture-focused and prescriptive but use highly abstract language that assumes domain knowledge about 'Native Core', 'layers', 'seams', and 'invariants'
  • No concrete examples provided to illustrate the abstract principles (e.g., what does 'trace entry point through layers' look like in practice?)
  • Scope is clear (feature development with focus on minimal viable work) but the execution guidance is vague and relies heavily on implicit system knowledge
  • The skill lacks actionable decision trees or checklists — an agent must infer what constitutes 'acceptance', 'material tradeoff', or 'coherent end-to-end path'
  • No documented limitations or edge cases (e.g., how to handle requests that span multiple architectural boundaries)
  • The phrase 'Keep work runnable; preserve Core safety' is mentioned but not defined — unclear what constitutes a safety violation
  • No supporting context on how to identify 'fitting seams' or when refactoring is justified
  • Strong architectural vision but insufficient scaffolding for agents unfamiliar with the specific system's design principles
Model: claude-haiku-4-5-20251001Analyzed: Aug 17, 2026

Reviews

Add this skill to your library to leave a review.

No reviews yet

Be the first to share your experience.

Use juliusbrussee/lean-build in your dev environment

Command Palette

Search for a command to run...