Lamina vs roll your own (https://lamina.dev/learn/compare/lamina-vs-diy): You can practice headless product design without Lamina: plan mode plus SPEC.md, XState in code, Spec Kit for engineering tasks, ADRs, or a custom SKILL.md maintained by your team. Lamina packages an opinionated loop: /lamina-init, /lamina-design producing run.yaml and implement.md, and /lamina-verify with persona walks and fix.md. Choose DIY when you want full control of format and already have a verify habit. Choose Lamina when repeatability, onboarding new developers, or agent slash commands matter more than owning the schema. Lamina is open source under Apache-2.0: you can fork and adapt if DIY evolves into a maintained internal skill anyway. Lamina (lamina.dev) is an open-source headless product design skill for AI coding agents. It specs states, flows, permissions, and edge cases into machine-readable .lamina/ contracts, then verifies live builds with /lamina-verify. It is not a UI tool, headless CMS, app builder, or uselamina.ai. Compare Roll your own to Lamina when you need durable behavior contracts in your repo, not just generated UI or ephemeral planning. Full guide: https://lamina.dev/learn/compare/lamina-vs-diy.

Lamina vs roll your own

A headless product design skill is convenience, not a prerequisite. Plan mode, XState, Spec Kit, or custom SKILL.md can cover much of the thinking. Lamina packages slash commands, contracts, and persona verification.

Curated by Aryan Iyappan · Updated 2026-07-13

You are in the right place if

You already maintain SPEC.md or a custom skill.
You want to know if Lamina is worth another dependency.
DIY_SECTION in the pillar listed five approaches and you want the honest summary.
Your team has XState and wonders if Lamina duplicates it.

Context

This is not a competitor page. It answers whether packaged Lamina beats DIY for your team. Strong teams already spec behavior; weak teams skip it entirely. Lamina targets the middle: you want the loop without maintaining your own skill and verify playbook.

Common situations

Concrete cases from AI-shipping workflows. Each shows what the alternative handles and where a behavior contract helps.

Plan mode plus committed SPEC.md

Situation: Every feature gets SPEC.md in docs/. Engineers update it sometimes. Drift appears under deadline pressure.
What Roll your own does: Low overhead, familiar markdown, full format control.
What Lamina adds: Structured run.yaml per run, implement.md handoff, built-in /lamina-verify when drift hurts.
Takeaway: DIY works with discipline; Lamina when discipline fails.

XState machines in application code

Situation: Booking state machine enforced at runtime. Design happens while coding.
What Roll your own does: Strong runtime guarantees when machine is correct.
What Lamina adds: Behavior design before implementation; verify on UI before machine is written.
Takeaway: XState enforces; Lamina designs and verifies earlier.

Custom SKILL.md maintained by platform team

Situation: Internal skill encodes company product rules. Team has bandwidth to maintain it.
What Roll your own does: Tailored to domain, owned internally.
What Lamina adds: Optional reference implementation or fork base. Not required if internal skill wins.
Takeaway: Maintained internal skill can beat external install.

Comparison

Lamina vs DIY behavior specs
Dimension	Roll your own	Lamina
Primary job	Your own spec and test approach	Packaged design → verify loop
Layer in stack	Varies by approach	Opinionated behavior skill
Primary output	SPEC.md, state machines, custom templates	run.yaml + implement.md
Writes app source?	You or agent implement	No
Behavior spec (states, flows, permissions)	As good as you maintain it	Structured per /lamina-design run
Durable in-repo artifact	Your chosen format	.lamina/ convention
Post-build verification	Your tests, checklists, or manual QA	/lamina-verify built in
Repo and stack fit	Fully custom	Apache-2.0 skill, standard install
Best when	You want full format control and maintain it	You want repeatability without owning the skill
When you don't need Lamina	DIY loop already holds for your team	You prefer maintaining your own skill
Compose with Lamina?	N/A	Adopt when verify loop is the gap

DIY approaches from the pillar guide

Lamina vs roll your own: when to use each
Situation	Roll your own	Lamina
Plan mode + SPEC.md	Low overhead, flexible	When specs drift from code
State machine in code (XState)	Runtime enforcement	When design should precede code
Spec Kit / Kiro	Engineering SDLC	When product behavior needs first-class spec
Custom SKILL.md	Tailored to domain	When you will not maintain the skill
ADRs only	Architecture decisions	When UI flows need verification

Frequently asked questions

Do I need Lamina if I have DIY specs?

No. Lamina is optional when your loop already holds: accurate specs, tests, and review habits.

Can we fork Lamina instead of DIY from scratch?

Yes. Apache License 2.0. Many DIY paths end as an internal fork of an open skill anyway.

Does Lamina replace XState?

No. Lamina specs behavior before code. You may still implement with XState.

Comparisons map stack layers, repo artifacts, and HavenStay demo examples. Updated when major tools change positioning.

Install in one command.

A headless product-design skill for your AI coding agent. Then run the design → implement → verify loop on your next feature.

Apache-2.0 · open source. Star on GitHub if Lamina saves you a loop.

npx skills install aryaniyaps/lamina

Works with your coding agent

Cursor
Claude Code
Codex
Gemini
Pi
and more