Skip to content
Back to search

lamina

Headless product design for AI coding agents, backed by a transactional product graph | Design how it works, verify what you ship.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/aryaniyaps--lamina/badge.svg)](/listings/aryaniyaps--lamina)

HTML

<a href="/listings/aryaniyaps--lamina"><img src="/api/listings/aryaniyaps--lamina/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

Let your AI agent install it

Open your project root, paste this into your AI coding agent, and let it handle setup:

Install Lamina for this project.

1. Install the standalone Lamina CLI (no Node.js or npm required):
   macOS/Linux: curl -fsSL https://github.com/aryaniyaps/lamina/releases/latest/download/install.sh | sh
   Windows PowerShell: iwr https://github.com/aryaniyaps/lamina/releases/latest/download/install.ps1 -UseBasicParsing | iex
2. Run: lamina doctor --json
3. Install all Lamina skills for this active agent only: use `-a codex` in
   Codex, `-a claude-code` in Claude Code, or `-a cursor` in Cursor. Do not use
   `-a '*'`.
   npx skills add aryaniyaps/lamina --skill '*' -a <active-agent> -y
4. Install passive rules for that provider:
   lamina setup --agent <codex|claude-code|opencode|cursor>
5. Node.js/npm are required only for the preceding `npx skills` command. Do not use sudo and do not edit application source during setup. If this is not yet a
   Git project, `/lamina-init` may create Git metadata but must not stage or
   commit files.
6. If a command fails, stop and show me
   the exact error.
7. When complete, report the installed CLI version and agent targets, then tell me to start a fresh agent session and run:
   /lamina-init <your product domain and primary users>

Prefer installing it yourself?

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|opencode|cursor>
lamina doctor --json

The installer downloads the matching CLI and private native CocoIndex worker from GitHub Releases and verifies both against `SHA256SUMS`. Graph observation needs no host Node, npm, Python, `uv`, or virtual environment; graphd remains the only process that owns Ladybug.

The install adds 10 public skills: four workflow entrypoints and six capability skills. Focused guidance lives in on-demand topic references inside those capabilities, keeping discovery small without flattening the underlying craft. Then start a **fresh agent session** so the complete skill set is available.

Initialize once, then ask normally

**AGENT CHAT**

/lamina-init <your product domain and primary users>

Run init once per project or domain. Use `/lamina-init update` only when the business use case, market, scope, or actors materially change.

On a new folder, init creates `.git` with an unborn `main` branch when needed. It never stages or creates an initial commit.

**ORDINARY CODING MODE**

Add medication schedule editing with conflict-safe saves and a responsive UI.

That is the whole ongoing interface. For a new or changed flow, the installed rules first run one independent design-time walk per Persona—even when no implementation exists. Those walks expand missing nodes, permissions, states, Scenarios, Invariants, recovery paths, and edge cases into the graph until the current round returns an empty discovery matrix. Lamina then compiles a bounded ImplementationPacket, runs `lamina work map` to scaffold every requirement and Persona-bound case, resolves them to immutable `modify|create` implementation/test file entries, implements, runs case-bound live proof, fixes failures, and reverifies. It does not dump the entire graph into the prompt.

`/lamina-design` and `/lamina-verify` remain advanced overrides when you want a graph-only design pass or a source-read-only audit. They are not required steps and Lamina should not recommend them during normal work.

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 316 lines · 3 findings marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center">
  2. <img src="brand/assets/wordmark/lamina-lockup-readme.svg" alt="lamina" width="360" />
  3. </p>
  4. <p align="center"><em>Design is how it works — not just how it looks.</em></p>
  5. <p align="center">
  6. Headless product design for AI coding agents, backed by a transactional product graph. Initialize once; then ordinary feature requests automatically give your coding agent the relevant actors, flows, states, permissions, failures, code targets, and proof obligations.
  7. </p>
  8. ---
  9. **Documentation:** [lamina.dev/docs](https://lamina.dev/docs)
  10. ## Quickstart
  11. ### Let your AI agent install it
  12. Open your project root, paste this into your AI coding agent, and let it handle setup:
  13. ```text
  14. Install Lamina for this project.
  15. 1. Install the standalone Lamina CLI (no Node.js or npm required):
  16. macOS/Linux: curl -fsSL https://github.com/aryaniyaps/lamina/releases/latest/download/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 25 on GitHub
  17. Windows PowerShell: iwr https://github.com/aryaniyaps/lamina/releases/latest/download/install.ps1 -UseBasicParsing | iex
  18. 2. Run: lamina doctor --json
  19. 3. Install all Lamina skills for this active agent only: use `-a codex` in
  20. Codex, `-a claude-code` in Claude Code, or `-a cursor` in Cursor. Do not use
  21. `-a '*'`.
  22. npx skills add aryaniyaps/lamina --skill '*' -a <active-agent> -y
  23. 4. Install passive rules for that provider:
  24. lamina setup --agent <codex|claude-code|opencode|cursor>
  25. 5. Node.js/npm are required only for the preceding `npx skills` command. Do not use sudo and do not edit application source during setup. If this is not yet a
  26. Git project, `/lamina-init` may create Git metadata but must not stage or
  27. commit files.
  28. 6. If a command fails, stop and show me
  29. the exact error.
  30. 7. When complete, report the installed CLI version and agent targets, then tell me to start a fresh agent session and run:
  31. /lamina-init <your product domain and primary users>
  32. ```
  33. Prefer installing it yourself?
  34. ```bash
  35. curl -fsSL https://github.com/aryaniyaps/lamina/releases/latest/download/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 46 on GitHub
  36. npx skills add aryaniyaps/lamina --skill '*' -a <active-agent> -y
  37. lamina setup --agent <codex|claude-code|opencode|cursor>
  38. lamina doctor --json
  39. ```
  40. The installer downloads the matching CLI and private native CocoIndex worker
  41. from GitHub Releases and verifies both against `SHA256SUMS`. Graph observation
  42. needs no host Node, npm, Python, `uv`, or virtual environment; graphd remains
  43. the only process that owns Ladybug.
  44. The install adds 10 public skills: four workflow entrypoints and six capability
  45. skills. Focused guidance lives in on-demand topic references inside those
  46. capabilities, keeping discovery small without flattening the underlying craft.
  47. Then start a **fresh agent session** so the complete skill set is available.
  48. ### Initialize once, then ask normally
  49. **AGENT CHAT**
  50. ```text
  51. /lamina-init <your product domain and primary users>
  52. ```
  53. Run init once per project or domain. Use `/lamina-init update` only when the business use case, market, scope, or actors materially change.
  54. On a new folder, init creates `.git` with an unborn `main` branch when needed.
  55. It never stages or creates an initial commit.
  56. **ORDINARY CODING MODE**
  57. ```text
  58. Add medication schedule editing with conflict-safe saves and a responsive UI.
  59. ```
  60. That is the whole ongoing interface. For a new or changed flow, the installed
  61. rules first run one independent design-time walk per Persona—even when no
  62. implementation exists. Those walks expand missing nodes, permissions, states,
  63. Scenarios, Invariants, recovery paths, and edge cases into the graph until the
  64. current round returns an empty discovery matrix. Lamina then compiles a bounded
  65. ImplementationPacket, runs `lamina work map` to scaffold every requirement and
  66. Persona-bound case, resolves them to immutable `modify|create`
  67. implementation/test file entries, implements, runs case-bound live proof,
  68. fixes failures, and reverifies. It does not dump the entire graph into the
  69. prompt.
  70. `/lamina-design` and `/lamina-verify` remain advanced overrides when you want a
  71. graph-only design pass or a source-read-only audit. They are not required steps
  72. and Lamina should not recommend them during normal work.
  73. ---
  74. ## How it works
  75. Your coding agent writes app source. Optional UI skills handle look and feel. **Lamina owns the product-behavior contract** — what to build, how states and flows work, and which failures and edges must be covered.
  76. <p align="center">
  77. <img
  78. src="docs/public/diagrams/product-loop.svg"
  79. alt="Lamina workflow: initialize product knowledge, publish a validated design, implement it, verify the live product, apply findings, and re-verify; contract gaps return to design."
  80. width="100%"
  81. />
  82. </p>
  83. | Step | Who | Result |
  84. |---|---|---|
  85. | 0. Init | **Lamina** | Business context plus Product, Actor, and Persona knowledge |
  86. | 1. Walk | **Independent Persona simulations** | Node-by-node permissions, states, branches, edge cases, and graph discoveries |
  87. | 2. Prepare | **Lamina + your agent** | Converged graph closure, Persona-bound Cases, ranked code context, and a mechanically scaffolded, checked WorkMap |
  88. | 3. Build | **Your coding agent** | App source in any stack, mapped to product obligations and Experience Cases |
  89. | 4. Verify | **Lamina + your agent** | Runtime Mission evidence plus state-scoped functional, visual, responsive, and accessibility evidence |
  90. | 5. Fix and reverify | **Your coding agent + Lamina** | Current evidence for every obligation and Experience Case |
  91. Human-readable implementation, report, and fix documents are optional projections from a resolved `GraphVersion`. They are useful handoffs, but they are not canonical state. Legacy run files are left untouched and have no runtime meaning.
  92. ---
  93. ## Under the hood
  94. Lamina keeps a local transactional product graph for each Git repository:
  95. - Product intent, observed source behavior, agent inference, persona simulation, and runtime evidence stay separate.
  96. - Multi-part design changes publish atomically: the whole change lands, or none of it does.
  97. - Conflicting facts remain visible as contradictions instead of silently overwriting each other.
  98. - Every active Persona independently walks every proposed flow node before implementation.
  99. - Experience Cases compile directly from current Persona walks; no second
  100. authored contract copies them.
  101. - Every active Persona gets an independent verification Mission.
  102. - Lamina's managed observer derives source observations; `graphd` owns the canonical Ladybug graph.
  103. Use `lamina graph status` to inspect the active graph. See the [transactional graph reference](docs/content/reference/transactional-graph.mdx) for Resources, Statements, sessions, GraphVersions, missions, evidence, and the complete CLI.
  104. ---
  105. ## Fits your stack
  106. Lamina slots into whatever you already use. It is unopinionated about your tech stack and AI tooling.
  107. | | |
  108. |---|---|
  109. | **Any AI coding tool** | Cursor, Claude Code, Codex, Gemini, Pi, etc. |
  110. | **Any framework** | Next.js, Angular, Astro, Svelte, React Native, Flutter, FastAPI, Gin, Express, etc. |
  111. | **Any database** | Postgres, MySQL, MongoDB, Cassandra, Redis, Neo4j, etc. |
  112. | **Any language** | JavaScript, Python, Go, Rust, Elixir, PHP, C#, etc. |
  113. | **Any UI library** | Tailwind CSS, Chakra UI, shadcn/ui, MUI, etc. |
  114. | **Any UI design skill** | Impeccable, UI UX Pro Max, `frontend-design`, etc. |
  115. | **Any workflow skill** | obra/superpowers, mattpocock/skills, everything-claude-code, etc. |
  116. | **Any interface** | Websites, mobile apps, desktop apps, PWAs, chatbots, CLIs, etc. |
  117. ---
  118. ## Demo: a hotel booking platform
  119. We built a demo hotel booking platform called HavenStay. The same prompt produced two apps — one with Lamina and one without. Both were built from scratch by **Cursor Composer 2.5**, with no human-written app code.
  120. > **Legacy demo:** HavenStay predates the transactional graph runtime. It remains a comparison of Lamina's product-design and verification value, not a guide to the current installation or storage model.
  121. <details>
  122. <summary><strong>The prompt</strong></summary>
  123. ```text
  124. Design and build a complete hotel booking platform called HavenStay from scratch.
  125. Create a production-ready product that enables travelers to discover, compare, book,
  126. and manage hotel stays, while enabling hotels to manage their properties, rooms,
  127. pricing, availability, reservations, and guest interactions.
  128. The product should feel polished, cohesive, and ready for real-world use. Design every
  129. aspect of the experience, including the end-to-end user journeys, information
  130. architecture, navigation, search and discovery, booking lifecycle, account management,
  131. payments, cancellations, reviews, notifications, hotel management, trust and safety,
  132. customer support, accessibility, edge cases, and system behavior.
  133. ```
  134. </details>
  135. | | **With Lamina** | **Without Lamina** |
  136. |---|---|---|
  137. | **Folder** | [`demo/hotel-booking-with-lamina`](demo/hotel-booking-with-lamina) | [`demo/hotel-booking-without-lamina`](demo/hotel-booking-without-lamina) |
  138. | **Workflow** | `/lamina-init` once → ordinary implementation prompts with passive Lamina context | Cursor Plan mode → implement |
  139. <p align="center">
  140. <img src="demo/hotel-booking-with-lamina/screenshot.png" alt="HavenStay built with Lamina" width="48%" />
  141. &nbsp;
  142. <img src="demo/hotel-booking-without-lamina/screenshot.png" alt="HavenStay built without Lamina" width="48%" />
  143. </p>
  144. <p align="center"><sub>Left: With Lamina · Right: Without Lamina</sub></p>
  145. Both apps cover traveler search and booking, a hotel-partner surface, and an admin role. The gap is **product behavior** — marketplace integrity, operational depth, and edge cases — not whether a screen exists.
  146. <details>
  147. <summary><strong>What Lamina covered — and the other build missed</strong></summary>
  148. - A 15-minute checkout inventory hold with countdown, hold-aware availability, and expiry.
  149. - Per-property cancellation policies with an immutable policy snapshot at booking.
  150. - Admin approval, rejection, or requested changes before a property goes live.
  151. - Multi-step property onboarding with a readiness checklist.
  152. - Hotel cancellation with a required reason and automatic full guest refund.
  153. - A full platform admin surface for approvals, users, bookings, payments, trust, reviews, tickets, and audit.
  154. - Traveler edges such as email verification, refund preview, review-window gating, and receipts.
  155. - Search that excludes unavailable or non-live properties for the selected dates.
  156. - A complete booking lifecycle plus suspension behavior that blocks booking.
  157. </details>
  158. ---
  159. ## Pair with
  160. Lamina keeps product decisions and verification evidence in one transactional graph. Pair it with tools that implement or polish the resulting contract:
  161. | Tool or skill category | Examples | Why |
  162. |---|---|---|
  163. | **Implementation workflows** | obra/superpowers, mattpocock/skills, everything-claude-code | Turn Lamina's implementation and fix projections into structured coding, testing, and review work. |
  164. | **UI/UX tools and skills** | Impeccable, UI UX Pro Max, `frontend-design`, design-focused agents | Polish the interface while Lamina focuses on behavior, states, permissions, edges, and verification. |
  165. | **Specification-driven engineering** | Spec Kit, Kiro, specification-first workflows | Convert a resolved GraphVersion projection into engineering plans and tasks without making prose canonical product truth. |
  166. ---
  167. ## Why not …?
  168. Most of these tools are complementary. Lamina is the product contract plus the post-build verification loop.
  169. ### Impeccable, UI UX Pro Max, `frontend-design`
  170. **They polish how it looks.** Lamina designs how it works — actors, flows, empty/error/loading states, permissions, invariants, and recovery. Pair any UI skill; Lamina stays out of pixels.
  171. ### BMAD, ai-ux-skills, design-skills
  172. **They teach design judgment** — heuristics, critique, accessibility, and PRDs. Lamina runs a workflow: ordinary request → transactional product contract → mapped implementation → live-product verification. Use craft skills for judgment and Lamina when you need a durable contract and evidence-backed check.
  173. ### Just asking your coding agent
  174. Fine for happy paths. Weak on permission matrices, stale states, cross-actor handoffs, and mid-flow failures. Lamina structures behavior before the build and exercises the live product afterward.
  175. ### Spec Kit, Kiro, spec-driven development
  176. **Product first, then engineering spec.** Lamina structures product behavior and compiles its obligations into the coding context; spec tools can further structure implementation work.
  177. ### v0, Lovable, Bolt
  178. **They generate apps** — often within a preferred stack. Lamina does not generate app source or choose your framework. It focuses on the role hierarchies, multi-step flows, state transitions, and domain edges that app generators commonly miss.
  179. ### Figma and design handoffs
  180. Mocks show screens. They do not capture every legal state or verify the build. Lamina produces an agent-ready behavior contract and checks the implemented product; visual design tools remain useful alongside it.
  181. **Choose Lamina** if you build with AI and care about product correctness, not just UI polish.
  182. **Skip it** for landing-page skins, no-code generation, or work that does not need an explicit product-behavior contract.
  183. ---
  184. ## Commands
  185. | Command | What it does |
  186. |---|---|
  187. | `/lamina-init` | Establish the product domain, actors, and personas once per project or domain |
  188. | `lamina setup --agent …` | Install idempotent passive rules for Codex, Claude Code, OpenCode, or Cursor |
  189. | `lamina context status` | Show retrieval freshness, generation, digests, counts, and failures |
  190. | `lamina context rebuild` | Discard and reconstruct the disposable local retrieval index |
  191. | `lamina design prepare-walk` | Compile one coverage-bound design task for one Persona |
  192. | `lamina design record-walk` | Record that isolated walk as engine-owned simulated graph evidence |
  193. | `lamina work prepare` | Synchronize hybrid retrieval, select Workflow roots, and compile exact graph obligations |
  194. | `lamina work map` | Mechanically scaffold every obligation and Experience Case row for file resolution |
  195. | `lamina work check` | Require complete obligation/case-to-code-and-test mapping before edits |
  196. | `lamina work verify` | Require current case-bound evidence and all state-scoped UI audit classes |
  197. | `/lamina-design` | Advanced graph-only design override |
  198. | `/lamina-verify` | Advanced source-read-only verification override |
  199. The Lamina CLI does not edit application source or prescribe visual styling;
  200. the coding agent implements only after the WorkMap gate passes.
  201. ---
  202. ## Development
  203. ```bash
  204. corepack pnpm install --frozen-lockfile
  205. corepack pnpm test
  206. ```
  207. Before any resource-intensive benchmark, experiment, fixture, or Lamina
  208. subprocess, inspect and qualify the crash-safe runner, then execute one tier at
  209. a time through its canonical command:
  210. ```bash
  211. npm run safe:envelope
  212. npm run safe:self-test
  213. npm run safe:run -- --tier small --workload <stable-id> --report /absolute/path/to/result.json --promote -- <audited-entrypoint> [args]
  214. ```
  215. Medium and large runs fail closed without aggregate Linux cgroup-v2
  216. enforcement, a current self-test attestation, sequential promotion evidence,
  217. and complete cleanup. Unknown commands and direct fixture-vendoring launches are
  218. refused. Retry and promotion bind complete argv, the physical content-hashed
  219. executable, cwd-relative input files, frozen Git source, and runner build; that
  220. identity is rechecked again at the inner quota gate. The report slot is
  221. invalidated with a current-run non-success record before preparation, an
  222. active-attempt fence exists before release, and graphd uses a durable
  223. reserve-before-spawn, bind-after-spawn, seal-after-readiness protocol. See the
  224. [crash-safe runner guide](docs/content/advanced/safe-runner.mdx).
  225. The standalone CLI, matching private native CocoIndex worker, and shared
  226. offline retrieval model are published as checksum-verified assets on the
  227. [GitHub Releases page](https://github.com/aryaniyaps/lamina/releases).
  228. ## License
  229. Licensed under the [Apache License 2.0](./LICENSE). Copyright 2026 Aryan Iyappan.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.