Lamina

Documentation: lamina.dev

Install

npx skills install aryaniyaps/lamina

Fits your stack

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

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
  DESIGN["/lamina-design"]
  IMPL["Implement"]
  VERIFY["/lamina-verify"]

  DESIGN -->|"implement.md"| IMPL
  IMPL -->|"live app"| VERIFY
  VERIFY -->|"fix.md / contract delta"| DESIGN

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.

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.yaml / 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.

Quickstart

/lamina-init Exam hall ticket system for universities
/lamina-design Hall ticket download with payment gate and venue assignment
# … build with your coding agent from implement.md …
/lamina-verify
# … fix product issues from fix.md with your coding agent …
/lamina-verify

Output: .lamina/runs/<id>/. Hand implement.md to build; hand fix.md to fix after verify.

Commands

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