# Lamina

> Design how it works. Headless product-design skill for AI coding agents. Invoke with slash commands — /lamina-init, /lamina-design, /lamina-verify — to spec how your app works into a contract your agent implements, then verify your application with parallel persona walks.

Lamina is an open-source skill licensed under Apache-2.0 that designs product behavior before your coding agent ships app source. Run slash commands explicitly — Lamina does not activate passively after install. UI skills dress the app; Lamina designs how it behaves — states, roles, flows, edge cases, and permission matrices.

Positioning: Product-design skill for developers who build with AI — know what to build, iterate faster.

Who it's for: Developers using AI coding agents (Cursor, Claude Code, Codex, Gemini, Pi) — not designers or PMs.

The loop: /lamina-init → /lamina-design → implement → /lamina-verify → fix. Run slash commands explicitly in agent chat — Lamina does not activate passively after install. Slash commands produce `.lamina/` artifacts; your coding agent implements app source; Lamina verifies the live build.

Lamina (lamina.dev) is an open-source product-design skill for AI coding agents — not uselamina.ai (creative API for media generation).

Key facts:

- Not a UI library — never writes app source or picks your component library
- Not an app builder — does not generate stack-locked apps like v0 or Lovable
- Not a pixel skill — Impeccable and frontend-design polish how it looks; Lamina designs how it works
- Open-source Apache-2.0 — https://github.com/aryaniyaps/lamina
- Install: `npx skills install aryaniyaps/lamina`
- Commands: /lamina-init, /lamina-design, /lamina-verify, /lamina (optional router)
- Machine-readable contract (`run.json`) your agent implements from `implement.md`
- Parallel persona walks that surface product gaps on the live app
- Fix loop (`fix.md` → agent fixes → re-verify) until the contract holds
- Fits any stack — framework, database, language, UI library, and AI coding tool
- Creator: Aryan Iyappan (https://aryaniyappan.com)
- Contact: https://github.com/aryaniyaps/lamina/issues

## Product

- [Homepage](https://lamina.dev): Product overview, positioning, and install command
- [What is Lamina?](https://lamina.dev/docs/concepts/what-is-lamina): Behavior vs pixels, comparisons, core principles
- [HavenStay demo](https://lamina.dev/docs/guides/demo-havenstay): Side-by-side build with and without Lamina
- [Quickstart](https://lamina.dev/docs/getting-started/quickstart): Run the full init → design → implement → verify loop
- [Installation](https://lamina.dev/docs/getting-started/installation): Install in Cursor, Claude Code, Codex, Gemini, or Pi

## Learn

- [Learn hub](https://lamina.dev/learn): Educational guides on headless product design for AI coding agents: FAQs, comparisons, and guide index
- [What is headless product design?](https://lamina.dev/learn/what-is-headless-product-design): Category definition: behavior contracts for AI coding agents, vs UI skills, headless CMS, and app builders
- [Compare Lamina to your workflow](https://lamina.dev/learn/compare): UI skills, app builders, plan mode, spec tools, and more
- [Lamina vs Impeccable](https://lamina.dev/learn/compare/lamina-vs-impeccable): Impeccable polishes how your app looks. Lamina specs how it works: states, flows, permissions. Compare layers for AI agent workflows.
- [Lamina vs Google Stitch](https://lamina.dev/learn/compare/lamina-vs-stitch): Google Stitch generates high-fidelity UI from prompts. Lamina specs product behavior and verifies the live build.
- [Lamina vs shadcn/ui skill](https://lamina.dev/learn/compare/lamina-vs-shadcn-skill): The shadcn/ui agent skill makes component code correct. Lamina specs product behavior. Compare UI layer vs behavior layer.
- [Lamina vs UI design skills](https://lamina.dev/learn/compare/lamina-vs-ui-skills): UI design skills polish pixels. Lamina specs headless product design behavior. Compare the UI skill category for AI agents.
- [Lamina vs Figma to code](https://lamina.dev/learn/compare/lamina-vs-figma-to-code): Figma to code translates screens into UI. Lamina specs product behavior before implementation.
- [Lamina vs v0](https://lamina.dev/learn/compare/lamina-vs-v0): v0 generates React UI from prompts. Lamina specs headless product design behavior in .lamina/ and verifies live builds. Compare generation vs contracts.
- [Lamina vs Magic Patterns](https://lamina.dev/learn/compare/lamina-vs-magic-patterns): Magic Patterns generates design-system UI. Lamina specs headless product design behavior and verifies live builds. Compare UI gen vs contracts.
- [Lamina vs app builders](https://lamina.dev/learn/compare/lamina-vs-app-builders): v0, Lovable, and Bolt generate apps. Lamina specs headless product design behavior in your repo with behavior contracts and verification.
- [Lamina vs plan mode](https://lamina.dev/learn/compare/lamina-vs-plan-mode): Plan mode helps you think. Lamina produces behavior contracts and verifies the live build. Compare ephemeral planning vs durable specs.
- [Lamina vs spec tools](https://lamina.dev/learn/compare/lamina-vs-spec-tools): Spec tools structure engineering work. Lamina structures product behavior before the engineering spec.
- [Lamina vs product-design skill](https://lamina.dev/learn/compare/lamina-vs-product-design-skill): The mblode product-design skill handles interaction judgment. Lamina produces behavior contracts and verifies live builds.
- [Lamina vs E2E tests](https://lamina.dev/learn/compare/lamina-vs-e2e-tests): /lamina-verify walks behavior contracts. E2E tests assert scenarios. Compare persona walks vs Playwright.
- [Lamina vs headless CMS](https://lamina.dev/learn/compare/lamina-vs-headless-cms): Headless CMS separates content from presentation. Headless product design separates behavior from app source. Not the same thing.
- [Lamina vs uselamina.ai](https://lamina.dev/learn/compare/lamina-vs-uselamina-ai): lamina.dev is a product-design skill for AI agents. uselamina.ai is a separate media API. Not affiliated.
- [Lamina vs roll your own](https://lamina.dev/learn/compare/lamina-vs-diy): You can spec behavior with plan mode, XState, or custom SKILL.md. Lamina packages the design → verify loop.
- [What is Lamina?](https://lamina.dev/docs/concepts/what-is-lamina): Product overview: behavior vs pixels, the design → implement → verify loop, and where Lamina sits in your stack.
- [HavenStay demo walkthrough](https://lamina.dev/docs/guides/demo-havenstay): Same hotel booking app built twice: with a behavior contract specced first, and without.
- [Pair Lamina with your stack](https://lamina.dev/docs/guides/pair-with): Compose with UI skills, plan mode, and engineering spec tools without overlap.

## Benchmarks

- [Harbor v4 AI coding agent benchmark](https://lamina.dev/benchmarks): Locked methodology, four matched workflows, four public tasks, declared fairness controls, limitations, and commit-pinned sources. Results are not published; no scores or winner claims appear.
- [Benchmark documentation](https://lamina.dev/docs/advanced/lamina-bench): Harbor v4 protocol, task corpus, matched-arm design, and release lifecycle


## Licensing

- [RSL policy](https://lamina.dev/rsl.txt): Permitted AI use, attribution, and content update cadence for lamina.dev

## Documentation

- [Product design skill for AI coding agents](https://lamina.dev/docs): Lamina is a headless product-design skill for AI coding agents. Spec states, edges, and flows into a contract your agent implements, then verifies with persona walks.
- [First run](https://lamina.dev/docs/getting-started/first-run): What to expect on your first Lamina design-verify cycle
- [Installation](https://lamina.dev/docs/getting-started/installation): Install the Lamina skill in your AI coding agent
- [Quickstart](https://lamina.dev/docs/getting-started/quickstart): Run the Lamina design, implement, and verify loop with one bounded product flow
- [Troubleshooting](https://lamina.dev/docs/getting-started/troubleshooting): Common Lamina issues and how to resolve them
- [Brownfield and greenfield](https://lamina.dev/docs/concepts/brownfield-and-greenfield): Designing and verifying on new vs existing codebases
- [Contracts and runs](https://lamina.dev/docs/concepts/contracts-and-runs): The .lamina/ directory structure, artifact model, and run lifecycle
- [Personas](https://lamina.dev/docs/concepts/personas): Parallel subagents walk your app as real actors with distinct goals
- [The loop](https://lamina.dev/docs/concepts/the-loop): Design, implement, verify, and fix — the Lamina workflow cycle
- [What is Lamina?](https://lamina.dev/docs/concepts/what-is-lamina): Headless product-design skill for AI coding agents — behavior, not pixels
- [Commands overview](https://lamina.dev/docs/commands/index): Lamina slash commands for design, verify, and routing
- [/lamina](https://lamina.dev/docs/commands/lamina): Router command — optional routing via /lamina <request> to design, verify, or direct answers
- [/lamina-design](https://lamina.dev/docs/commands/lamina-design): Design how the product works — contract to ready_to_build plus implement.md
- [/lamina-init](https://lamina.dev/docs/commands/lamina-init): Establish or update the domain charter and actor cast
- [/lamina-verify](https://lamina.dev/docs/commands/lamina-verify): Walk the live product against the contract — persona walks to fix.md
- [Demo: HavenStay](https://lamina.dev/docs/guides/demo-havenstay): Hotel booking marketplace built with Lamina — compare with and without Lamina
- [What to pair](https://lamina.dev/docs/guides/pair-with): Tools and skills that complement Lamina in your AI coding stack
- [Pair with Spec Kit](https://lamina.dev/docs/guides/pair-with-spec-kit): Lamina for product behavior, Spec Kit for engineering plans
- [Pair with UI skills](https://lamina.dev/docs/guides/pair-with-ui-skills): Lamina for behavior, UI skills for pixels — recommended workflow
- [Working with findings](https://lamina.dev/docs/guides/working-with-findings): Read fix.md, implement product fixes, handle contract deltas, and re-verify
- [Per-run artifacts](https://lamina.dev/docs/reference/artifacts): Files written to .lamina/runs/<id>/ during design and verify
- [Global artifacts](https://lamina.dev/docs/reference/global-artifacts): Project-wide files in .lamina/ written by /lamina-init and updated across runs
- [Glossary](https://lamina.dev/docs/reference/glossary): Key terms in the Lamina design-verify workflow
- [Contract v2 product graph](https://lamina.dev/docs/reference/run-json-schema): The canonical JSON contract produced by Lamina Design.
- [Skill map](https://lamina.dev/docs/reference/skill-map): Capability skills behind Lamina — systems thinking, UX, and agent simulation
- [Contract validation](https://lamina.dev/docs/reference/validation): Validate, derive, render, scope, and inspect Contract v2 graphs.
- [LaminaBench](https://lamina.dev/docs/advanced/lamina-bench): Harbor v4 behavior benchmark that proves Lamina works under matched arms
- [Orchestrator](https://lamina.dev/docs/advanced/orchestrator): How Lamina coordinates skills, workflows, audit profiles, and subagent patterns

## Optional

- [Full docs dump](https://lamina.dev/llms-full.txt): Complete markdown export of all docs — skip if per-page URLs suffice
- [GitHub](https://github.com/aryaniyaps/lamina): Source, issues, and contributions
- [Creator](https://aryaniyappan.com): Aryan Iyappan