The loop

Lamina’s workflow is a closed loop: design the contract, implement with your agent, verify against the live app, fix gaps, re-verify.

Quick path


/lamina-init → /lamina-design → [implement] → /lamina-verify → [fix] → /lamina-verify

Workflow diagram


┌─────────────┐     ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   DESIGN    │ ──▶ │  IMPLEMENT  │ ──▶ │   VERIFY    │ ──▶ │     FIX     │
│   Lamina    │     │  Your agent │     │   Lamina    │     │  Your agent │
└─────────────┘     └─────────────┘     └─────────────┘     └─────────────┘
       ▲                                                            │
       └──────────────────── RE-VERIFY ◀────────────────────────────┘

Ownership

Step	Owner	Command / action	Writes
Charter	Lamina	`/lamina-init`	`.lamina/business-context.md`, `personas.json`
Design	Lamina	`/lamina-design`	`run.json`, `run.md`, `implement.md`
Implement	Your agent	Build from `implement.md`	App source
Verify	Lamina	`/lamina-verify`	Updated `run.json` findings, `report.md`, `fix.md`, optional `walkthrough/`
Fix	Your agent	Apply `fix.md`	App source
Re-verify	Lamina	`/lamina-verify` again	Updated findings

Advanced: Lamina writes only under .lamina/ during slash commands. Your coding agent writes app source in separate coding sessions. This is Mode B — the non-negotiable write boundary.

Design phase

Lamina models the domain:

Entities and states — what exists and what state it is in
Actors and roles — who interacts with the product
Dependencies — reachability graph for cross-feature prerequisites
Workflows — primary paths, alternate paths, operations over states
Scenarios — violations, edge cases, recovery paths
Screens — structural UX surfaces (no styling)

Output: run.json, run.md, and implement.md with status ready_to_build.

Implement phase

Your coding agent reads implement.md and writes app source. Lamina does not participate in implementation — it stays headless. Use any stack, framework, database, and UI library.

Verify phase

/lamina-verify runs parallel persona walks at base_url:

One subagent per primary actor
Optional visual walkthrough capture in walkthrough/ when live capture is available
Invariant probes against invariants[]
Reachability probes against dependencies[]
Accessibility checks on captured steps
Findings written to findings[] with fix_target per item

Fix phase

Your agent applies fixes from fix.md:

`fix_target`	Action
`product`	Fix app code in a normal coding session from `fix.md`
`contract`	Re-run `/lamina-design` with scoped update
`ops`	Report-only — observation stays in `report.md`; excluded from `fix.md`; does not block exit

Lamina does not implement fixes — it writes the brief for product and contract gaps only.

Contract delta path

When verify reveals the contract itself is wrong (not just the app), findings have fix_target: contract. This loops back to design instead of implementation:


verify → fix_target: contract → /lamina-design (scoped) → implement → verify

When the loop ends

The loop completes when /lamina-verify reports zero open product or contract findings and the contract holds on the live build. fix_target: ops observations may remain in report.md and do not block this exit.

Next steps

Commands overview — per-command reference
Working with findings — fix loop deep dive
Contracts and runs — artifact model