Golden Templates
A curated, build-verified exemplar app an agent starts from and adapts to the prompt, rather than reconstructing app structure from a blank slate. The pitch is "adapt, don't invent": hosted no-code builders (Lovable, Replit Agent, v0) feel magical because they already "know" what a todo app or a CRM should contain — a golden-template library packages that same product knowledge locally so a coding agent inherits it instead of re-deriving screens, entities, and states each time. What separates a golden template from a generic scaffold is verification: the exemplar is proven to build (compiled/type-checked in CI), so "adapt from this" is trustworthy rather than a guess. Templates come in two tiers — runnable starters copy real, build-verified source into the user's folder, while planned packs don't copy source yet but emit a scoped implementation plan + app spec + reference list, so the long tail still builds from a real contract rather than from nothing. Curated exemplars pair with a registry of reusable micro-blocks (filterable table, detail panel, stat-card grid, entity form, empty state) that the agent composes instead of reinventing each UI unit.
Claims
- Adapt a proven, build-verified exemplar instead of reconstructing app structure from scratch. best practice — context: common app types with a recognizable shape (todo, CRM, dashboard, notes); it reduces blank-page variance and inherits the product knowledge hosted builders hide. Skip it for a one-off component or throwaway script — a raw agent is enough — and the long tail without a runnable starter still gets a planned spec, not a copy.
- A template only earns "golden" status if it is build-verified (compiled/type-checked in CI), not merely written. best practice — context: shipping exemplars an agent copies and adapts; verification is what makes "adapt, don't invent" trustworthy rather than a scaffold that may not even build. This is Eval-Driven Development's "measure, don't vibe" applied to the starter itself — the CI build is the eval.
- Ship exemplars in two tiers — runnable starters copy real source; planned packs emit a scoped implementation plan + app spec + reference list — so the long tail builds from a real contract, not a blank slate. observation — the tiering is how coverage of the common case (copy-and-adapt) and the tail (plan-and-implement) are handled without pretending every app type has verified source.
- Compose UIs from a curated registry of reusable micro-blocks rather than reinventing each unit per app. best practice — context: building app UIs where the same product units (tables, detail panels, stat cards, forms, empty states) recur; the blocks are compact references the agent adapts to the selected template and entities, not automatic code composition.
- Runnable coverage is a small, curated set that grows release over release; the source claims 15 runnable starters + 61 recognized archetypes and 9→15 runnable in v0.3. observation — the source's own numbers (groundable), and the honest framing that "golden" is deliberately narrow, not exhaustive.
- The pattern generalizes past apps to any generative output with a recognizable shape — a slide skill ships a library of 30+ opinionated HTML templates (designed from curated reference images), and the agent picks one by the mood and content of the deck. observation — a second, independent source (Front End Slides) applies "curate opinionated exemplars, then select-and-adapt" to slide design; the templates exist specifically because ungrounded generation "came out generic," which is Golden Templates's blank-page-variance argument restated in a new domain.
Related
- Spec-Driven Development — the app spec is the what/why contract; a golden template is a verified implementation the spec adapts. Templates supply the code SDD would otherwise regenerate from the spec.
- Eval-Driven Development — CI build-verification is the eval that makes a template "golden"; the review gate then grades the adapted output against rubrics.
- Context Routing — only the selected template's references are loaded, never every template; the plan routes the agent to the one exemplar it needs.
- Search-Then-Get — the same progressive-disclosure discipline: ship a large brain, load only the slice (the chosen starter + its references) into context.
- Agentic Simplicity — adapt-don't-invent is the simplest move that produces a real prototype: reuse a proven exemplar instead of building structure from first principles.
- Distillate: Buildable — A Local, Build-Verified App-Builder Brain for Coding Agents.
- Distillate: Stop Making PowerPoints: Vibe-Coding HTML Slides as a Skill — curated opinionated exemplars (30+ slide templates from reference images) the agent selects and adapts, built to fix generic output.
Linked from
- AI Second Brain
- Anthropic's Claude Cookbooks — the canonical recipe index
- Eval-Driven Development
- HTML as Native Output
- I Gave Claude Code a Permanent Memory
- This Week
- Repo-Local Capability Binding
- Skill Artifact Transfer
- Spec-Driven Development
- STORM: A Fixed Panel of Adversarial Research Lenses, Packaged as a Skill
- Stop Making PowerPoints: Vibe-Coding HTML Slides as a Skill
- Buildable — A Local, Build-Verified App-Builder Brain for Coding Agents