Lamina vs plan mode (https://lamina.dev/learn/compare/lamina-vs-plan-mode): Plan mode in Cursor, Claude Code, or similar agents is structured conversational thinking before implementation: you explore requirements, tradeoffs, and approach in a plan thread. Lamina is a headless product-design skill that turns behavior into durable artifacts: run.yaml and implement.md in .lamina/, then /lamina-verify walks the live build as personas. Plan mode alone works for small features with one actor and no gates, especially when you manually test afterward. It breaks down when specs drift after merge, permission matrices are never written down, or multiple roles share the same UI. Use plan mode to explore; use /lamina-design when you need contracts that survive the session and verification on the real app. 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 Plan mode 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-plan-mode.

Lamina vs plan mode

Plan mode is conversational thinking in Cursor or Claude. Lamina produces machine-readable contracts in .lamina/ and walks the live app after implementation.

Curated by Aryan Iyappan · Updated 2026-07-13

You are in the right place if

You plan features well but specs drift after the agent implements.
You want permission matrices and persona verification, not just a plan thread.
Plan mode produced a great SPEC.md that nobody updated after the first PR.
You asked the agent to plan checkout and still shipped pay-before-verify.

Context

Plan mode is the default workflow for thoughtful AI development. It is genuinely useful. The gap is durability and verification: plans live in chat or ad-hoc markdown, and nothing walks the deployed UI as guest vs partner unless you do it manually. Lamina does not replace thinking; it formalizes behavior output and adds a verify loop your plan thread does not provide.

Common situations

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

Plan mode checkout design, implementation drifts

Situation: You spent twenty minutes in plan mode on guest checkout. Agent implemented from memory. Hold timer and email gate were dropped in the second PR.
What Plan mode does: Plan mode captured intent in conversation and maybe a SPEC.md snippet.
What Lamina adds: run.yaml committed in git. implement.md is the handoff. verify catches drift on staging.
Takeaway: Plans without committed contracts drift.

Single-actor bug fix with clear scope

Situation: Fix a typo on settings label. No new states or permissions.
What Plan mode does: Plan mode or direct agent prompt is enough.
What Lamina adds: Overhead not justified. Skip Lamina.
Takeaway: Small scope: plan mode alone is fine.

Multi-role partner onboarding

Situation: Plan mode listed onboarding steps in prose. Agent built a single form; partner and admin capabilities conflated.
What Plan mode does: Narrative plan with step list.
What Lamina adds: Actor permissions, stepped gates, submit-for-review rules, persona verify.
Takeaway: Multi-actor features need machine-readable specs.

Comparison

Lamina vs plan mode and ad-hoc prompts
Dimension	Plan mode	Lamina
Primary job	Structured thinking before coding	Behavior contracts + verification
Layer in stack	Exploratory planning in agent UI	Headless product design skill
Primary output	Plan thread, sometimes SPEC.md	run.yaml + implement.md
Writes app source?	Agent may implement from plan	No
Behavior spec (states, flows, permissions)	Narrative when prompted well	Structured states and permissions
Durable in-repo artifact	Often ephemeral unless you commit manually	Always in .lamina/ per run
Post-build verification	Manual QA or ad-hoc agent testing	/lamina-verify persona walks
Repo and stack fit	Built into Cursor, Claude Code	Any agent with skills
Best when	Small features, one actor, no gates	Roles, gates, multi-step flows
When you don't need Lamina	Trivial change with manual QA	Plan mode and your tests cover it
Compose with Lamina?	Explore requirements in plan mode	Formalize with /lamina-design, then implement

Workflow

Lamina vs plan mode: recommended workflow
Step	Plan mode	Lamina
1	Plan feature in Cursor or Claude plan mode	Optional: same exploration in chat
2	Agent implements from plan summary	/lamina-design → committed implement.md
3	You manually click-test critical paths	/lamina-verify → fix.md loop
4	Update plan doc if you remember	Contract in git is source of truth

When to use which

Lamina vs plan mode: when to use each
Situation	Plan mode	Lamina
Rename a component	Plan mode or direct edit	Skip
Guest vs partner permissions	Plan for thinking only	Contract + verify
Spike prototype, throw away	Plan mode	Skip

Worked example

Partner onboarding gate before submit. Plan mode can list onboarding steps in prose. Lamina specs submit locked until prerequisites complete and verify walks the partner path. HavenStay showed a complete form on step one when only planning was used.

HavenStay demo walkthrough

Frequently asked questions

Does Lamina replace plan mode?

No. Plan in plan mode, then run /lamina-design when behavior must survive implementation.

I already commit SPEC.md from plan mode. Is that enough?

If your SPEC.md stays accurate, tests cover flows, and you never drift, you may not need Lamina. Many teams drift without a verify loop.

Does this apply to Cursor plan mode and Claude Code?

Yes. The comparison is planning as a modality vs durable behavior contracts, regardless of vendor.

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