Compare Lamina to your AI workflow
Lamina keeps product behavior in a validated GraphVersion, gives your coding agent query projections, and verifies the live build with independent Persona Missions. These guides clarify how that layer differs from tools you already use, including honest when-you-do-not-need-Lamina guidance. HavenStay examples are always marked as legacy pre-graph proof.
Curated by Aryan Iyappan · Updated 2026-07-27
Find your comparison
Pick the situation closest to yours.
- My UI looks wrong or I installed a design skillUI design skills →
- I generate UI from Figma, v0, or similarDesign-to-code workflows →
- I already plan, spec, or test before codingPlan mode and spec tools →
- I am confused by naming (headless, wrong Lamina)Category disambiguation →
- Flows break after merge despite good UIWhat is headless product design? →
At-a-glance matrices
Condensed comparisons for AI answer engines. Open a spoke page for the full table and workflow.
UI design skills
| Dimension | Impeccable | Google Stitch | shadcn/ui skill | Lamina |
|---|---|---|---|---|
| Layer | UI craft skill | UI design canvas | Component skill | Transactional product graph + agent workflow |
| Primary output | DESIGN.md, critique | Screens, exports | Correct component code | Validated GraphVersion + query projections |
| Behavior spec | UI presentation states | Visual layout | Component APIs | Domain states, permissions |
| Post-build verification | Visual critique | Canvas iteration | CLI / docs lookup | Independent Persona Missions + runtime evidence |
| Compose with Lamina? | Yes, polish after | Yes, after export | Yes, during implement | N/A |
Design-to-code workflows
| Dimension | Figma to code | v0 | Magic Patterns | Lamina |
|---|---|---|---|---|
| Layer | Design handoff | UI generation | Design-system UI gen | Transactional product graph + agent workflow |
| Primary output | UI from frames | React components | Brand-aligned UI | Validated GraphVersion + query projections |
| Writes app source? | Via agent | Exports generated code | Exports components | No |
| Behavior spec | Visual only | Happy-path implied | Component-level | Validated graph statements |
| Repo fit | Your repo + Figma | Often greenfield export | Existing design system | Any repo and agent |
Spec and thinking
| Dimension | Plan mode | Spec Kit / Kiro | product-design skill | Lamina |
|---|---|---|---|---|
| Layer | Exploratory planning | Engineering spec | Interaction judgment | Transactional product graph + agent workflow |
| Durable artifact | Often ephemeral | Engineering tasks | Judgment references | Validated GraphVersion + query projections |
| Behavior spec | Narrative when prompted | Task acceptance criteria | Reachable UI states | Domain state machines |
| Post-build verification | Manual QA | Automated tests | Review / lint modes | Persona Missions + runtime evidence |
| Best when | Small, single-actor features | Breaking engineering work | Interaction choice | Roles, gates, multi-step flows |
Category disambiguation
| Dimension | Headless CMS | uselamina.ai | E2E tests only | Lamina |
|---|---|---|---|---|
| What it is | Content API | Media generation API | Regression test suite | Transactional product graph + agent workflow |
| Primary job | Deliver content | Generate media | Assert scenarios | Publish behavior + verify |
| Same as Lamina? | No | No | No | Yes |
| Compose with Lamina? | Yes, content layer | No relation | Yes, after verify | N/A |
UI design skills and tools
Pixels, components, and visual craft. Lamina designs behavior underneath.
Lamina vs Impeccable
Impeccable is a UI craft skill: critique, tokens, accessibility, and visual polish. Lamina is a transactional product graph and agent workflow: validated graph knowledge and live verification. They pair; they do not overlap.
Lamina vs Google Stitch
Google Stitch is an AI UI design canvas: prompts to screens, export to Figma or code. Lamina specs behavior in your repo and verifies implementation.
Lamina vs shadcn/ui skill
The shadcn/ui skill gives your agent project-aware component context. Lamina specs product behavior and verifies flows.
Lamina vs UI design skills
UI design skills make interfaces look better. Lamina makes product behavior correct. Use both when flows matter.
Design-to-code and UI generators
Figma handoff, v0, Magic Patterns, and app builders.
Lamina vs Figma to code
Figma to code answers what it looks like. Lamina answers what states exist, who can transition, and what happens on failure.
Lamina vs v0
v0 generates UI. Lamina specs behavior in the local product graph for your agent and stack.
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.
Lamina vs app builders
App builders generate stack-locked apps. Lamina specs behavior in the local product graph for your agent and stack.
Spec, thinking, and verification
Plan mode, engineering specs, similar skills, and E2E tests.
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.
Lamina vs spec tools
Spec Kit, Kiro, and similar tools structure engineering tasks and acceptance criteria. Lamina specs product-level states, roles, and flows, then feeds GraphVersion projection into your workflow.
Lamina vs product-design skill
mblode product-design is an agent skill for interaction judgment: reachable UI states, action scope, resilience. Lamina publishes validated GraphVersions and runs /lamina-verify on the live build.
Lamina vs E2E tests
E2E tests (Playwright, Cypress) assert scenarios you code after the fact. /lamina-verify walks the live build as personas against the resolved graph knowledge and surfaces gaps in product findings.
Category clarity
Headless CMS, uselamina.ai, and rolling your own.
Lamina vs headless CMS
A headless CMS (Contentful, Sanity, Strapi) manages content APIs for your frontend. Lamina specs product behavior in the local product graph for your coding agent. Both use headless; different layers.
Lamina vs uselamina.ai
Lamina at lamina.dev is an open-source transactional product graph and agent workflow for AI coding agents. uselamina.ai is a creative API for media generation. Different products, no affiliation.
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.
Frequently asked questions
Is Lamina a UI design tool like Impeccable or Stitch?
No. Lamina's layer is a transactional product graph plus agent workflow. UI tools own visual craft.
Why not just use plan mode?
Plan mode helps you think. Lamina publishes validated GraphVersions and verifies the live app after implementation.
Does /lamina-verify replace Playwright?
No. Verify finds behavior gaps from contracts during development. E2E encodes regressions in CI. See the E2E comparison.
Is Lamina a headless CMS?
No. Headless CMS delivers content APIs. Lamina specs product behavior. See the headless CMS comparison.
Where should I start?
Read the headless product design guide, pick the comparison that matches your stack, then install when ready.
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 | shnpx skills add aryaniyaps/lamina --skill '*' -a <active-agent> -ylamina setup --agent <codex|claude-code|cursor>lamina doctor --json