For developers who build with AI

Design how it works.

UI skills dress the app. Lamina designs how it behaves.

QuickstartStar on GitHub

AI shipped it. You found the gaps.

  • Impossible states ship as real

    Cancelled and confirmed. Sold out and bookable. Unverified and checked out. AI builds screens that allow combinations the product should never allow.

  • Dependencies get skipped

    Publish without approval. Pay without a hold. Invite without a role. Prerequisites that define the product disappear — the agent only wired the happy sequence.

  • States have no way out

    Users get stuck mid-flow with no cancel, retry, or handoff. Valid paths in, missing transitions out — the state machine was never designed, only generated.

Install in one command.

A headless product-design skill for your AI coding agent — then run the design → implement → verify loop on your next feature.

MIT · open source. Star on GitHub if Lamina saves you a loop.

npx skills install aryaniyaps/lamina

Works with your coding agent

  • Cursor
  • Claude Code
  • Codex
  • Gemini
  • Pi
  • and more

Product behavior, not another UI skill.

Lamina structures product behavior — states, edges, and flows — before your agent writes a line of app code.

  • Design is how it works

    The only AI skill for product behavior — not pixels.

  • Design skills agents lack

    UI skills polish pixels. Lamina teaches product behavior — states, roles, recovery — so your agent builds the right thing.

  • Persona-based simulation

    Parallel subagents walk your application as real actors — travelers, admins, partners — not one generic user.

Any interface, any stack

Web, mobile, desktop, CLI — Lamina slots into your framework, database, and UI layer. Pair any design skill; Lamina stays out of pixels and never writes app source.

Next.js
Next.js
React
React
Vue
Vue
Angular
Angular
Astro
Astro
Svelte
Svelte
Expo
Expo
Flutter
Flutter
NestJS
NestJS
Django
Django
Postgres
Postgres
MongoDB
MongoDB
Redis
Redis
Supabase
Supabase
Prisma
Prisma
Tailwind
Tailwind
TypeScript
TypeScript
Docker
Docker
Vercel
Vercel
Cloudflare
Cloudflare

Missing your stack? Lamina is unopinionated — if your agent can read implement.md, it fits.

Compatible with stacks including Next.js, React, Vue, Angular, Astro, Svelte, Expo, Flutter, NestJS, Django, Postgres, MongoDB, Redis, Supabase, Prisma, Tailwind, TypeScript, Docker, Vercel, Cloudflare.

Design → implement → verify → fix.

Your coding agent writes app source. Lamina owns product behavior — what to build, how states and flows work, which edges to cover. The loop shows up in the session itself.

Annotated agent session transcript showing the design, implement, verify, and fix loop as JSONL
session.jsonl
JSONL
  1. DESIGN

    Domain charter → run.yaml + implement.md

    {
      "role": "user",
      "message": {
        "content": [
          {
            "type": "text",
            "text": "/lamina-design guest checkout — hold, pay, cancel"
          }
        ]
      }
    }
  2. {
      "role": "assistant",
      "message": {
        "content": [
          {
            "type": "text",
            "text": "Contract ready → .lamina/runs/a3f2/"
          }
        ]
      }
    }
  3. IMPLEMENT

    Your agent writes app source — Lamina never does

    {
      "role": "user",
      "message": {
        "content": [
          {
            "type": "text",
            "text": "Implement from .lamina/runs/a3f2/implement.md"
          }
        ]
      }
    }
  4. {
      "role": "assistant",
      "message": {
        "content": [
          {
            "type": "tool_use",
            "name": "Write",
            "input": {
              "path": "app/checkout/page.tsx"
            }
          }
        ]
      }
    }
  5. VERIFY

    Persona walks + invariants → fix.md

    {
      "role": "user",
      "message": {
        "content": [
          {
            "type": "text",
            "text": "/lamina-verify"
          }
        ]
      }
    }
  6. {
      "role": "assistant",
      "message": {
        "content": [
          {
            "type": "text",
            "text": "3 findings → .lamina/runs/a3f2/fix.md"
          }
        ]
      }
    }
  7. FIX

    Agent applies product fixes from fix.md

    {
      "role": "user",
      "message": {
        "content": [
          {
            "type": "text",
            "text": "Fix from .lamina/runs/a3f2/fix.md"
          }
        ]
      }
    }
  8. {
      "role": "assistant",
      "message": {
        "content": [
          {
            "type": "tool_use",
            "name": "StrReplace",
            "input": {
              "path": "lib/holds.ts"
            }
          }
        ]
      }
    }
  9. RE-VERIFY

    Loop until the contract holds

    {
      "role": "user",
      "message": {
        "content": [
          {
            "type": "text",
            "text": "/lamina-verify"
          }
        ]
      }
    }
  10. {
      "role": "assistant",
      "message": {
        "content": [
          {
            "type": "text",
            "text": "Contract holds. 0 open findings."
          }
        ]
      }
    }

Same prompt. Two builds. Product behavior is the gap.

HavenStay — a hotel booking platform built from scratch by Cursor Composer 2.5 with no human-written app code. With Lamina vs without.

View demo source
WITH LAMINAWITHOUT LAMINA
Screenshot without Lamina — WITHOUT LAMINA
Screenshot with Lamina — WITH LAMINA

Drag or use arrow keys to compare · Same prompt, two builds — Cursor Composer 2.5, no human app code

What Lamina designed into the build

Behaviors the without-Lamina build skipped

  • Guest checkout

    Inventory hold with countdown

    15-minute hold and hold-aware availability — a room can’t stay bookable while someone else is paying.

  • Cancellation

    Policy locked at booking

    Flexible / Moderate / Strict per property, snapshotted immutably when the guest books.

  • Partner go-live

    Admin gate before publish

    Property goes live only after approve, reject, or request-changes — not on submit alone.

  • Partner onboarding

    Wizard with readiness checklist

    Multi-step setup that tracks what’s still missing before a property can accept guests.

  • Guest cancel

    Reason required, refund automatic

    Cancel path asks why, then triggers the guest refund from the snapshotted policy.

Four commands. One contract loop.

Install once, then run init → design → verify around your coding agent. Output stays in .lamina/runs/<id>/— no app source, no visual styling.

Glass terminal quickstart showing install and the Lamina command loop
lamina — zsh
  1. $ npx skills install aryaniyaps/lamina
  2. # Domain charter — Scope the product domain before design
  3. /lamina-init Exam hall ticket system for universities
  4. # Design contract — Writes ready_to_build contract to .lamina/runs/<id>/
  5. /lamina-design Hall ticket download with payment gate and venue assignment
  6. # … build with your coding agent from implement.md …
  7. # Verify — Persona walks surface gaps → fix.md when needed
  8. /lamina-verify
  9. # … fix product issues from fix.md with your coding agent …
  10. # Verify again — Re-run until the contract holds
  11. /lamina-verify

add real product design skills to your agent

QuickstartStar on GitHub

npx skills install aryaniyaps/lamina