Lamina vs roll your own (https://lamina.dev/learn/compare/lamina-vs-diy): You can practice product behavior 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 GraphVersion and GraphVersion projection, and /lamina-verify with independent Persona Missions and product findings. 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 Apache-2.0 open source: you can fork and adapt if DIY evolves into a maintained internal skill anyway. Lamina (lamina.dev) is an open-source transactional product graph and agent workflow. Its CLI and portable skills publish validated GraphVersions, produce query projections, and verify live builds with independent Persona Missions and runtime evidence. It is not a UI tool, headless CMS, app builder, or uselamina.ai. Compare Roll your own to Lamina when you need durable product knowledge in a local graph, not just generated UI or ephemeral planning. Full guide: https://lamina.dev/learn/compare/lamina-vs-diy.

Lamina vs roll your own

A transactional product graph and agent workflow 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 Missions with runtime evidence.

Curated by Aryan Iyappan · Updated 2026-07-27

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 validated graph knowledge and verification evidence help.

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 GraphVersion per run, GraphVersion projection 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	Transactional product graph + agent workflow
Primary output	SPEC.md, state machines, custom templates	Validated GraphVersion plus query projections
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	Validated GraphVersion plus query projections
Post-build verification	Your tests, checklists, or manual QA	Independent Persona Missions with runtime evidence
Repo and stack fit	Fully custom	CLI plus portable skills in any repo and stack
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-2.0 license. 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, durable outputs, and provenance-marked legacy examples. Updated when major tools change positioning.

Install Lamina with your agent.

Copy the repository-matched prompt. Your agent installs the standalone CLI, adds every Lamina skill for your active agent, configures supported passive rules, checks the setup, and tells you when to start a fresh session with /lamina-init.

Skills work across coding agents. Passive setup currently supports Codex, Claude Code, and Cursor.