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 transactional product graph and agent workflow that turns behavior into durable artifacts: GraphVersion and GraphVersion projection in the local product graph, 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 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 Plan mode 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-plan-mode.

Lamina vs plan mode

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

Curated by Aryan Iyappan · Updated 2026-07-27

You are in the right place if

You plan features well but specs drift after the agent implements.
You want permission matrices and Persona Missions with runtime evidence, 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 validated graph knowledge and verification evidence help.

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: GraphVersion committed in git. GraphVersion projection 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	validated graph knowledge + verification
Layer in stack	Exploratory planning in agent UI	Transactional product graph + agent workflow
Primary output	Plan thread, sometimes SPEC.md	Validated GraphVersion plus query projections
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	Validated GraphVersion plus query projections
Post-build verification	Manual QA or ad-hoc agent testing	Independent Persona Missions with runtime evidence
Repo and stack fit	Built into Cursor, Claude Code	CLI plus portable skills in any repo and stack
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 GraphVersion projection
3	You manually click-test critical paths	/lamina-verify → product findings loop
4	Update plan doc if you remember	The GraphVersion is canonical state

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 validated graph knowledge, regardless of vendor.

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.

Cursor
Claude Code
Codex
Gemini
Pi
and more

Install manually on macOS/Linux4 shell commands

Run these in your project, then start a fresh agent session. On Windows, use the PowerShell installer in the copied agent prompt.

curl -fsSL https://github.com/aryaniyaps/lamina/releases/latest/download/install.sh | sh

npx skills add aryaniyaps/lamina --skill '*' -a <active-agent> -y

lamina setup --agent <codex|claude-code|cursor>

lamina doctor --json