Lamina vs Magic Patterns (https://lamina.dev/learn/compare/lamina-vs-magic-patterns): Magic Patterns generates design-system-aware React components from prompts: brand tokens, patterns, and UI that match your existing system. Lamina is product behavior design for AI coding agents: it specs states, actor permissions, and flow recovery in the local product graph, then verifies the running application with independent Persona Missions. Magic Patterns accelerates component and screen generation; it does not define whether a guest may cancel with a refund preview or a partner may submit before Stripe connects. Use Magic Patterns when UI fidelity to your design system is the bottleneck. Add Lamina when multi-step flows, role permissions, or domain state machines are the bottleneck. Compose: generate UI, /lamina-design before integrating behavior-critical paths, /lamina-verify after deploy. Full guide at lamina.dev/learn/compare/lamina-vs-magic-patterns. 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 Magic Patterns 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-magic-patterns.

Magic Patterns generates design-system-aware React components from prompts: brand tokens, patterns, and UI that match your existing system. Lamina is product behavior design for AI coding agents: it specs states, actor permissions, and flow recovery in the local product graph, then verifies the running application with independent Persona Missions. Magic Patterns accelerates component and screen generation; it does not define whether a guest may cancel with a refund preview or a partner may submit before Stripe connects. Use Magic Patterns when UI fidelity to your design system is the bottleneck. Add Lamina when multi-step flows, role permissions, or domain state machines are the bottleneck. Compose: generate UI, /lamina-design before integrating behavior-critical paths, /lamina-verify after deploy. Full guide at lamina.dev/learn/compare/lamina-vs-magic-patterns.

Lamina vs Magic Patterns

Magic Patterns generates brand-aligned components. Lamina is a transactional product graph and agent workflow that specs behavior and verifies the running app.

Curated by Aryan Iyappan · Updated 2026-07-27

Magic Patterns generates on-brand UI. Lamina specs product behavior design: validated graph knowledge and live verification.

You are in the right place if

Components match your design system but flows skip prerequisites.
Magic Patterns output merges cleanly yet partner gates are missing.
You generate screens fast but QA finds illegal product states.

Context

Magic Patterns targets teams with an established design system who want generated UI that does not fight their tokens. That is a different problem than behavior design. Generated components can be on-brand and still allow illegal transitions if domain rules were never specced.

Common situations

Concrete cases from AI-shipping workflows. Each shows what the alternative handles and where validated graph knowledge and verification evidence help.

On-brand wizard UI, wrong step order

Situation: Magic Patterns produced a stepped onboarding wizard matching brand components. Users can jump to the final step.
What Magic Patterns does: Generates branded stepper UI and form layouts.
What Lamina adds: Permission matrix for step advance and submit unlock.
Takeaway: Brand-accurate UI still needs behavior rules.

Isolated settings card refresh

Situation: Regenerate a profile card component with updated tokens. No flow changes.
What Magic Patterns does: Magic Patterns alone.
What Lamina adds: Skip Lamina.
Takeaway: Component isolation: visual tool only.

Checkout components from design system

Situation: Generated checkout matches design system. Hold banner renders but pay ignores hold expiry.
What Magic Patterns does: Provides checkout UI patterns from your system.
What Lamina adds: Hold lifecycle and pay preconditions in GraphVersion.
Takeaway: Pair generation with behavior spec for money paths.

Comparison

Lamina vs Magic Patterns
Dimension	Magic Patterns	Lamina
Primary job	Design-system-aware UI generation	validated graph knowledge and verify
Layer in stack	UI generation	Transactional product graph + agent workflow
Primary output	React components aligned to brand	Validated GraphVersion plus query projections
Writes app source?	Yes	No
Behavior spec (states, flows, permissions)	Component-level patterns	Actor flows and permissions
Durable in-repo artifact	Generated exports	Validated GraphVersion plus query projections
Post-build verification	Platform preview	Independent Persona Missions with runtime evidence
Repo and stack fit	Teams with design systems	CLI plus portable skills in any repo and stack
Best when	Brand-accurate UI at speed	Roles, gates, recovery paths
When you don't need Lamina	Isolated components, no flow rules	No domain behavior change
Compose with Lamina?	Generate UI	Spec → integrate → verify

Workflow

Lamina vs Magic Patterns: recommended workflow
Step	Magic Patterns	Lamina
1	Generate components in Magic Patterns	/lamina-design on feature
2	Export to repo	GraphVersion projection guides integration
3	Wire UI in app	Enforce contract server-side
4	Visual review	/lamina-verify

Worked example

Confirm cancel with refund preview. Magic Patterns can generate a cancel dialog matching your system. Lamina specs deliberate cancel flow: policy reminder, refund amount, confirm step. HavenStay verify found one-click cancel without preview when behavior was not contracted.

HavenStay demo walkthrough

Frequently asked questions

Can they work together?

Yes. Magic Patterns for UI; Lamina for behavior and verification.

Magic Patterns vs v0: where does Lamina fit?

Both are UI generators. Lamina sits after export for any generator when behavior matters.

We export Magic Patterns components without flow rules. When do we add Lamina?

Run /lamina-design on the first feature with roles, gates, or multi-step flows after export.

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