lamina

Design is how it works — not just how it looks.

Headless product-design skill for AI coding agents. Specs how your app works — states, edges, UX gaps — into a contract your agent implements, then verifies the live build with parallel persona walks. Never writes app source.

Documentation: lamina.dev/docs

Quickstart

SHELL — install once

npx skills install aryaniyaps/lamina

AGENT CHAT — open your project root and start a fresh session

/lamina-init <your product domain and primary users>
/lamina-design <one feature or flow>

Successful init produces and validates .lamina/business-context.md and .lamina/personas.json. Later design and verify commands gate on valid business-context.md. Run init once per project or domain; use /lamina-init update only when the business use case, market, scope, or actor cast materially changes.

ORDINARY CODING MODE — implement from the handoff

Implement from .lamina/runs/<run_id>/implement.md
Start the product

AGENT CHAT

/lamina-verify hall ticket download at http://localhost:3000

ORDINARY CODING MODE — apply fixes when findings remain

Apply .lamina/runs/<run_id>/fix.md

AGENT CHAT

/lamina-verify hall ticket download at http://localhost:3000 again

Design outputs: run.json, run.md, implement.md. Verify outputs: report.md, fix.md; walkthrough evidence is optional. Open product findings go to fix.md; contract gaps return to /lamina-design. Ops observations stay in report.md only — not applied from fix.md and do not block the product/contract exit condition.

Not sure which command to run? /lamina <what you are trying to do> is an optional router — not a required setup step.

How it works

Your coding agent writes app source. Optional UI skills handle look and feel. Lamina owns product behavior — what to build, how states and flows work, which edges to cover:

flowchart LR
  INIT["/lamina-init"]
  DESIGN["/lamina-design"]
  IMPL["Implement"]
  VERIFY["/lamina-verify"]
  FIX["Apply fix.md"]

  INIT -->|"business-context.md + personas.json"| DESIGN
  DESIGN -->|"implement.md"| IMPL
  IMPL -->|"live app"| VERIFY
  VERIFY -->|"product: fix.md"| FIX
  VERIFY -->|"contract delta"| DESIGN
  FIX -->|"live app"| VERIFY

Fits your stack

Lamina slots into whatever you already use. Unopinionated on your tech stack/ AI skills.

Demo: A Hotel Booking Platform

We built a demo hotel booking platform called HavenStay.
Same prompt, two builds — one with Lamina, one without. Both were built from scratch by Cursor Composer 2.5 with no human-written app code.

Design and build a complete hotel booking platform called HavenStay from scratch.

Create a production-ready product that enables travelers to discover, compare, book,
and manage hotel stays, while enabling hotels to manage their properties, rooms,
pricing, availability, reservations, and guest interactions.

The product should feel polished, cohesive, and ready for real-world use. Design every
aspect of the experience, including the end-to-end user journeys, information
architecture, navigation, search and discovery, booking lifecycle, account management,
payments, cancellations, reviews, notifications, hotel management, trust and safety,
customer support, accessibility, edge cases, and system behavior.

_{Left: With Lamina · Right: Without Lamina}

Both apps cover traveler search/booking, a hotel partner surface, and an admin role. The gap is product behavior — marketplace integrity, ops depth, and edge cases — not whether a screen exists.

• 15-minute checkout inventory hold with countdown, hold-aware availability, and expiry — Plan mode only decrements stock after payment.
• Per-property Flexible / Moderate / Strict cancellation policies with an immutable snapshot at booking — Plan mode uses one global refund tier.
• Property go-live requires admin approve / reject / request-changes — Plan mode lets partners self-publish.
• “List your property” → multi-step onboarding wizard with readiness checklist — Plan mode is flat forms + manual publish.
• Hotel can cancel a reservation with a required reason and automatic full guest refund — Plan mode has no hotel cancel path.
• Full platform admin console (approvals, users, bookings, payments, trust, reviews, tickets, audit) — Plan mode has a single KPI page.
• Traveler edges: email-verified booking gate, cancel flow with refund preview, review-window gating, and receipt on trip detail.
• Search only surfaces live properties and excludes sold-out inventory for the selected dates — Plan mode can still list unavailable hotels.
• Richer booking lifecycle states (PENDING_PAYMENT, CHECKED_IN, CANCELLED_BY_TRAVELER / _HOTEL, PAYMENT_FAILED) plus user suspension that blocks booking.

See the design report and verify report for the full contract and findings.

Pair with

Lamina designs and verifies product behavior. It works best when your agent can see the system cheaply and remember prior decisions:

Brownfield minimum: a codebase indexing tool + persistent memory.

Why not …?

Most of these are complementary. Lamina is the contract + verify loop.

Impeccable, UI UX Pro Max, frontend-design

They polish how it looks. Lamina designs how it works — actors, flows, empty/error/loading states, invariants. Pair any UI skill; Lamina stays out of pixels.

BMAD, ai-ux-skills, design-skills

They teach design judgment — heuristics, critique, a11y, PRDs. Collections like BMAD, ai-ux-skills, and design-skills improve how your agent thinks.

Lamina runs a workflow — slash commands → run.json / implement.md → live-app verify. Use craft skills for judgment; Lamina when you need an implementable contract and a post-build check.

Just asking your coding agent

Fine for happy paths. Weak on permission matrices, stale states, and mid-flow failures. Lamina structures before build and walks the live app after.

Spec Kit, Kiro, spec-driven dev

Product first, then spec. Spec tools structure engineering work; Lamina structures product behavior. Run /lamina-design, then feed implement.md into Spec Kit/Kiro. Spec tools don't walk your live UI.

v0, Lovable, Bolt

They generate apps — often stack-locked. Lamina doesn't generate code or pick your framework; it fits your repo, agent, and UI stack. Targets role hierarchies, multi-step flows, and domain edges those builders miss.

Figma / design handoff

Mocks show one screen. They aren't agent instructions and don't verify the build. Lamina outputs implement.md, then audits the live product. Coexist fine.

Choose Lamina if you're a developer who builds with AI and care about product correctness — not just UI polish.

Skip it for landing-page skins, no-code AI builders, or if you don't want a .lamina/ contract.

Commands

Writes to .lamina/ only. No app source. No visual styling.

License

Licensed under the Apache License 2.0. Copyright 2026 Aryan Iyappan.