Skip to main content

For developers who build with AI

Lamina designs how it works.

Design product behavior with your AI agent, backed by a transactional graph. Then verify what ships.

Read the quickstart

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 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 | sh
npx skills add aryaniyaps/lamina --skill '*' -a <active-agent> -y
lamina setup --agent <codex|claude-code|cursor>
lamina doctor --json

One graph for every product decision.

Lamina keeps intent, observations, inference, simulations, and evidence in one transactional graph without losing provenance. Read the graph reference

Layered product dashboard representing the application a coding agent builds
Typed mutations

Agents propose reviewable changes to actors, states, flows, decisions, and invariants.

Atomic versions

Every validated mutation publishes together as one new GraphVersion, or none of it does.

Interconnected product knowledge converging on one graph version
Runtime evidence

Independent Persona Missions verify the live build and return evidence to the graph.

User personas evaluated in independent mission lanes

Any interface, any stack

Web, mobile, desktop, CLI. If your agent can use the Lamina CLI, portable skills, and GraphVersion projections, the workflow fits. Your framework, database, UI layer, and application source stay yours.

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

Missing your stack? Lamina is unopinionated. If your agent can read the Lamina CLI, portable skills, and a resolved GraphVersion projection, it fits.

Design a version. Implement a projection. Verify the live product.

/lamina-init establishes Product, Actor, and Persona knowledge. Design publishes a validated GraphVersion; your coding agent implements from that resolved version; verify runs independent Persona Missions.

Product defects return to ordinary coding. Contract gaps return to a new design session. Expand a phase for the annotated session JSONL. Quickstart guide

Annotated agent session showing product knowledge, GraphVersion publication, implementation, and Persona Mission verification as JSONL
session.jsonl
JSONL
{
  "role": "user",
  "message": {
    "content": [
      {
        "type": "text",
        "text": "/lamina-design guest checkout: hold, pay, cancel"
      }
    ]
  }
}
{
  "role": "assistant",
  "message": {
    "content": [
      {
        "type": "text",
        "text": "GraphVersion v13 published atomically; implementation projection resolved"
      }
    ]
  }
}

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

HavenStay is a hotel booking platform built from scratch by Cursor Composer 2.5 with no human-written app code. This historical comparison tests Lamina's earlier product-design workflow. Full demo walkthrough

View demo source
With LaminaWithout Lamina
HavenStay without Lamina: Inventory hold with countdown
HavenStay with Lamina: Inventory hold with countdown

Drag or use arrow keys to compare · select a behavior to swap pairs

Lamina leads on all four Product Bench tasks

In the first public release, Lamina outscored direct and plan-first coding agents on every task.

Lamina mean
0.689
vs direct
+0.104
vs plan-first
+0.130
Tasks led
4/4

Four greenfield thin vertical slices · Cursor CLI + Composer 2.5 · median of three reruns

Explore Product Bench

Pair it with your AI coding stack

Lamina keeps product behavior in a transactional graph and verifies the build. Compare what your other tools own and where Lamina fits.

Pairing guide

Impeccable makes checkout look professional. Lamina makes pay-before-verify illegal.

How it looks

  • Impeccable
  • UI UX Pro Max
  • frontend-design
  • Google Stitch
  • Typography, layout, and visual hierarchy
  • Empty, loading, and error presentation

How it works

  • Actor permissions and legal state transitions
  • Flow recovery and mid-journey failures

Run when Screens look polished but checkout, onboarding, or permissions still break.Skip when You are refreshing a static page with no new product rules.

Compare UI skillsAll comparisons

Common questions

Answers to frequently asked questions about Lamina

What is Lamina?

A local transactional product graph plus CLI and agent skills for designing and verifying product behavior.

Does Lamina write my application code?

No. Your coding agent owns application source. Lamina resolves product knowledge and verification evidence.

What is Lamina's canonical state?

A validated GraphVersion in the local transactional graph. Generated documents are optional projections.

Is Lamina the same as uselamina.ai?

No. lamina.dev is a transactional product graph for AI coding agents. uselamina.ai is a separate media API.

Why do AI coding agents ship impossible product states?

Agents optimize for the happy path. Without a behavior contract, screens allow illegal combinations and skip gates the product needs.

Why use Lamina instead of plan mode or ad-hoc prompts?

Plan mode helps you think. Lamina keeps validated decisions across sessions and verifies the live build.

How is Lamina different from UI skills like Impeccable?

UI skills polish pixels. Lamina specs behavior: states, permissions, flows, recovery. They pair; they do not overlap.

How is Lamina different from v0, Lovable, or Bolt?

App builders generate apps. Lamina fits your repo and agent while your existing stack keeps ownership of source.

How do I install Lamina?

Copy the agent install prompt, let your agent install the CLI and all skills, then start a fresh session with /lamina-init.

How does the current design and verification loop work?

/lamina-design publishes a GraphVersion, your agent implements a projection, and /lamina-verify runs Persona Missions.

Give your agent product design it can keep in context.

Read the quickstartStar on GitHub

GraphVersion → implementation projection → Persona Missions