Skip to content
Back to search

vibex

SkillWorks with Claude CodeGitHub

vibeX: architecture diagrams and checkable docs from your codebase

Safety scan

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

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/Raja0sama/vibex with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/Raja0sama/vibex'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/raja0sama--vibex/badge.svg)](/listings/raja0sama--vibex)

HTML

<a href="/listings/raja0sama--vibex"><img src="/api/listings/raja0sama--vibex/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.

vibeX is a Claude Code / Codex skill first and a CLI second. Installed as a skill, the whole command surface collapses into a sentence — the agent reads `SKILL.md`, finds your schema, picks the diagram type, writes the spec and renders it:

> show me the data model
  wrote db.erd.json · db.erd.html

> now the endpoints
  wrote api.endpoints.json · api.endpoints.html

> what happens after a request is approved?
  wrote request.lifecycle.json · request.lifecycle.html

> document the auth service and fail CI when it drifts
  wrote auth.docs.json · 41 claims, 38 verified

**Install it.** Pick your agent:

| Agent | Command | |---|---| | Claude Code + Codex | `npx skills add Raja0sama/vibex -g -a claude-code -a codex -y` | | Claude Code plugin | `/plugin marketplace add Raja0sama/vibex`, then `/plugin install vibex@vibex` | | Codex, by hand | `git clone https://github.com/Raja0sama/vibex ~/.agents/skills/vibex` |

Then:

1. Restart the agent (or open a new session). 2. Ask: *"show me the data model"*.

`-g` installs for your user, so every project sees it. Codex reads `~/.agents/skills`; Claude Code gets a symlink in `~/.claude/skills`. The plugin route updates through `/plugin` instead.

Check it landed:

node ~/.agents/skills/vibex/bin/vibex.mjs types

<details> <summary><b>Other ways in</b>: per project, other agents, pinned to a release, or from source</summary>

<br>

**Per project**, so the skill is checked in beside the code it documents. Drop `-g` and run it inside the repo:

cd my-project && npx skills add Raja0sama/vibex -a claude-code -a codex -y

**Another agent** (Cursor, Gemini CLI, OpenCode, Copilot and more): swap the `-a` values, or run `npx skills add Raja0sama/vibex` and pick from the list.

**Pinned to a published version.** `SKILL.md` ships inside the npm package, so a global install plus one symlink does it:

npm i -g @vibex/vibex
ln -s "$(npm root -g)/@vibex/vibex" ~/.claude/skills/vibex   # or ~/.agents/skills/vibex for Codex

> Under nvm, `npm root -g` is scoped to the Node version you are on. Install a new > Node and both the `vibex` binary and this symlink stop resolving, silently. > `skills add` has no such problem.

**From source**, if you are changing vibeX itself. The symlink tracks your working copy, so edits apply the moment you save:

git clone https://github.com/Raja0sama/vibex && cd vibex
ln -s "$(pwd)" ~/.claude/skills/vibex

`skills add` and the plugin clone the repository, not the npm package, so they have no `node_modules`. Run `npm install` inside the skill folder only if you need YAML OpenAPI. The npm paths already have it.

</details>

---

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.

.claude-plugin/marketplace.json · Manifest · 13 lines

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

  1. {
  2. "name": "vibex",
  3. "owner": { "name": "Raja Osama", "url": "https://github.com/Raja0sama" },
  4. "description": "vibeX: architecture diagrams and checkable docs from your codebase",
  5. "plugins": [
  6. {
  7. "name": "vibex",
  8. "source": "./",
  9. "description": "ERD, C4, API endpoint, lifecycle, sequence and service-links diagrams from your code, plus documentation that fails CI when the code moves.",
  10. "category": "documentation"
  11. }
  12. ]
  13. }
README.md · README · 460 lines

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

  1. <div align="center">
  2. <img src="assets/favicon.svg" width="72" height="72" alt="">
  3. # vibeX
  4. ### Your architecture diagram is a lie.
  5. vibeX reads the thing that can't lie — your Prisma schema, your OpenAPI document,
  6. your GraphQL SDL, or the source itself — and renders the diagram that's actually true.
  7. Then it documents the system in claims that fail CI when the code moves underneath them.
  8. **One standalone HTML file. No server. Nothing leaves your network.**
  9. [![ci](https://github.com/Raja0sama/vibex/actions/workflows/ci.yml/badge.svg)](https://github.com/Raja0sama/vibex/actions/workflows/ci.yml)
  10. ![node](https://img.shields.io/badge/node-%E2%89%A518-2b6cb0)
  11. ![deps](https://img.shields.io/badge/dependencies-0-2f855a)
  12. ![license](https://img.shields.io/badge/license-MIT-718096)
  13. </div>
  14. ---
  15. ## The diagram you have right now
  16. - ~~a whiteboard photo in a Slack thread~~
  17. - ~~a Confluence page last touched in 2023~~
  18. - ~~a Miro board nobody can find~~
  19. - ~~a Mermaid block that stopped rendering~~
  20. - ~~the one guy who knows~~
  21. → **one command, run against the schema that actually ships.**
  22. ```bash
  23. npx skills add Raja0sama/vibex -g -a claude-code -a codex -y # Claude Code + Codex, then just ask
  24. npx @vibex/vibex demo out # or look first: installs nothing
  25. ```
  26. <div align="center">
  27. [![vibeX: four diagrams and a checkable document, from one command](https://img.youtube.com/vi/SovgqAX7oSY/hqdefault.jpg)](https://www.youtube.com/watch?v=SovgqAX7oSY)
  28. **[Watch the demo](https://www.youtube.com/watch?v=SovgqAX7oSY)**
  29. </div>
  30. ## Why "vibeX"
  31. **vibe** — how code gets written now. Fast, AI-assisted, more of it than anyone can hold in their head.
  32. **X** — the crossings. Which table joins which. Which service calls which. What happens after approval.
  33. > **You vibed it into existence. vibeX shows you what you actually built.**
  34. The mark is the same idea: two edges crossing. Everything interesting in a system is a
  35. line between two things, not the things themselves.
  36. ## Six diagrams. One source of truth.
  37. | | Type | What it draws | Import from |
  38. |---|---|---|---|
  39. | 🔵 | `erd` | tables, columns, PK/FK badges, crow's-foot cardinality that knows nullable from not, bounded contexts as groups | Prisma, GraphQL SDL (`--erd`) |
  40. | 🟣 | `c4` | persons, systems, containers, components, databases, queues, each with its own fill, inside tinted nested boundaries | hand-authored |
  41. | 🟢 | `endpoints` | REST routes, GraphQL operations, published events — grouped by resource, with method badges, auth, params, status codes | OpenAPI 2/3, GraphQL SDL |
  42. | 🟡 | `lifecycle` | every state a thing can reach and every legal move between them, with actor, event, guard and side effect on each arrow | hand-authored |
  43. | 🟠 | `sequence` | one request or job end to end: who calls whom, in order, with replies, async events, activation bars and `alt`/`opt`/`loop`/`par` branches | hand-authored |
  44. | 🔷 | `links` | the **System view**: every call between services, pinned to the client that makes it and the handler that serves it, across repositories | hand-authored from clients and handlers |
  45. Each is a validated JSON spec plus a rendered viewer. **The spec is the artifact you keep;
  46. the HTML is disposable.** Documentation and changes are two more views over the same
  47. specs, all in one dashboard file. Every diagram also exports as Mermaid
  48. (`vibex mermaid <spec>`, or the button in the viewer) for Markdown that renders it.
  49. **Which service calls which.** A `*.links.json` records each call once, anchored on both
  50. ends. `vibex links` checks it against the code:
  51. ```bash
  52. vibex links system.links.json docs --repo bff=../bff --repo orders=../orders --check
  53. ```
  54. It fails when a client or handler moved, an endpoint it names is gone, or a C4 arrow has
  55. no call behind it. It also lists endpoints nothing calls. In a monorepo, pass `--repo .`.
  56. ## Three commands. No config file.
  57. ```bash
  58. # 1. import — your schema becomes a draft spec
  59. vibex import prisma prisma/schema.prisma docs/db.erd.json
  60. vibex import openapi openapi.yaml docs/api.endpoints.json
  61. vibex import graphql schema.graphql docs/api.endpoints.json
  62. # 2. validate — dangling refs and unreachable states are errors that name the field
  63. vibex validate docs/db.erd.json
  64. # 3. render — one file, CSS and JS inlined, spec embedded
  65. vibex render docs/db.erd.json --open
  66. # or --linked: the HTML is only a placeholder; data goes in db.erd.data.js
  67. # and the viewer in vibex-viewer.js/.css beside it (still opens from disk)
  68. # every spec in the folder, one page, cross-linked
  69. vibex dashboard docs/index.html docs --title "Payments platform" --repo .
  70. # several repos side by side? run it from the folder above them:
  71. # a landing page plus one dashboard per repo, and the files to serve it
  72. vibex workspace ~/work --title "Payments platform" --host
  73. cd ~/work/vibex-site && VIBEX_USER=you VIBEX_PASSWORD=change-me docker compose up --build
  74. ```
  75. No source schema? It reads the code — NestJS controllers, GraphQL resolvers,
  76. TypeORM entities, Express routers, SQL migrations — and writes the spec itself.
  77. ## Install it as a skill and stop learning flags
  78. vibeX is a Claude Code / Codex skill first and a CLI second. Installed as a skill, the
  79. whole command surface collapses into a sentence — the agent reads `SKILL.md`, finds your
  80. schema, picks the diagram type, writes the spec and renders it:
  81. ```
  82. > show me the data model
  83. wrote db.erd.json · db.erd.html
  84. > now the endpoints
  85. wrote api.endpoints.json · api.endpoints.html
  86. > what happens after a request is approved?
  87. wrote request.lifecycle.json · request.lifecycle.html
  88. > document the auth service and fail CI when it drifts
  89. wrote auth.docs.json · 41 claims, 38 verified
  90. ```
  91. **Install it.** Pick your agent:
  92. | Agent | Command |
  93. |---|---|
  94. | Claude Code + Codex | `npx skills add Raja0sama/vibex -g -a claude-code -a codex -y` |
  95. | Claude Code plugin | `/plugin marketplace add Raja0sama/vibex`, then `/plugin install vibex@vibex` |
  96. | Codex, by hand | `git clone https://github.com/Raja0sama/vibex ~/.agents/skills/vibex` |
  97. Then:
  98. 1. Restart the agent (or open a new session).
  99. 2. Ask: *"show me the data model"*.
  100. `-g` installs for your user, so every project sees it. Codex reads `~/.agents/skills`;
  101. Claude Code gets a symlink in `~/.claude/skills`. The plugin route updates through
  102. `/plugin` instead.
  103. Check it landed:
  104. ```bash
  105. node ~/.agents/skills/vibex/bin/vibex.mjs types
  106. ```
  107. <details>
  108. <summary><b>Other ways in</b>: per project, other agents, pinned to a release, or from source</summary>
  109. <br>
  110. **Per project**, so the skill is checked in beside the code it documents. Drop `-g`
  111. and run it inside the repo:
  112. ```bash
  113. cd my-project && npx skills add Raja0sama/vibex -a claude-code -a codex -y
  114. ```
  115. **Another agent** (Cursor, Gemini CLI, OpenCode, Copilot and more): swap the `-a`
  116. values, or run `npx skills add Raja0sama/vibex` and pick from the list.
  117. **Pinned to a published version.** `SKILL.md` ships inside the npm package, so a
  118. global install plus one symlink does it:
  119. ```bash
  120. npm i -g @vibex/vibex
  121. ln -s "$(npm root -g)/@vibex/vibex" ~/.claude/skills/vibex # or ~/.agents/skills/vibex for Codex
  122. ```
  123. > Under nvm, `npm root -g` is scoped to the Node version you are on. Install a new
  124. > Node and both the `vibex` binary and this symlink stop resolving, silently.
  125. > `skills add` has no such problem.
  126. **From source**, if you are changing vibeX itself. The symlink tracks your working
  127. copy, so edits apply the moment you save:
  128. ```bash
  129. git clone https://github.com/Raja0sama/vibex && cd vibex
  130. ln -s "$(pwd)" ~/.claude/skills/vibex
  131. ```
  132. `skills add` and the plugin clone the repository, not the npm package, so they have
  133. no `node_modules`. Run `npm install` inside the skill folder only if you need YAML
  134. OpenAPI. The npm paths already have it.
  135. </details>
  136. ---
  137. ## Prose that can't quietly go stale
  138. > **An AI wrote the sentence once. Arithmetic checks it forever.**
  139. A diagram can't drift from the schema, because it's generated from it. Prose can, and
  140. always does. So `vibex docs` documents a system the same way it draws one — the unit
  141. isn't a page, it's a **claim**: one sentence with a source attached.
  142. ```bash
  143. vibex docs system.docs.json specs/ --repo . --check # exit 1 on any claim that no longer holds
  144. ```
  145. **There is no model in the verification path** — only `fs`, `path`, `crypto` and `git`.
  146. That is the whole point, and it is why a full drift check costs ~70ms and nothing per run.
  147. ### What it does not do
  148. It catches drift, not initial error. If the first draft misreads the code, the hash
  149. still matches, CI stays green, and a wrong claim can stay verified indefinitely.
  150. Reviewing the spec once, at authoring time, is the only thing that establishes truth.
  151. The honest version: **you get a reviewable first draft in one pass, and after you have
  152. read it once, arithmetic keeps it honest.**
  153. <details>
  154. <summary><b>How a claim works</b> — three sources, five computed confidence states</summary>
  155. <br>
  156. | Source | What holds it up |
  157. |---|---|
  158. | `derived` | Computed from a diagram spec by one of ten fixed generators. Cannot disagree with the diagram beside it, because it *is* the diagram. |
  159. | `anchored` | Prose pinned to a file and a symbol by a content hash. In languages where whitespace is not syntax (TypeScript, JSON, Go, …) the hash ignores it — reformat the file and nothing moves; change the line and the claim flags itself. Everywhere else (Python, YAML, Makefiles, any unknown extension) indentation counts, and only trailing whitespace and line endings are ignored. |
  160. | `asserted` | A person's decision, with their name and the date. For what no file can prove — and it expires, so "we decided this in March" can't pass for fact forever. |
  161. **Confidence is computed, never written.** A claim cannot declare how trustworthy it is.
  162. The build assigns one of five states from the evidence and the clock, and the validator
  163. rejects any claim that tries to rate itself:
  164. `verified` · `stated` · `needs re-reading` · `out of date` · `unverifiable`
  165. ```bash
  166. vibex docs system.docs.json specs/ --repo . --reanchor # re-pin hashes after a deliberate edit
  167. vibex docs system.docs.json specs/ --repo . --md doc.md # portable Markdown, zero raw HTML
  168. ```
  169. **Incremental, keyed on git.** `docs.lock.json` records the commit each claim last
  170. verified at, so a rebuild re-reads only what git says moved — and every uncertainty
  171. resolves toward reading *more*, never less. CI passes `--no-lock`: a lock file arrives
  172. from a contributor's machine *asserting* that claims were verified, and CI re-reads every
  173. anchor rather than taking that on trust.
  174. **It tells you what it doesn't cover.** Every document renders three lists: what was
  175. read, what is deliberately out of scope and why, and what the build noticed but could
  176. not account for. A document that implies completeness gets believed exactly where it
  177. is wrong.
  178. **One artefact, two readers.** People read the dashboard panel; agents read `docs.json` —
  179. every fact once, addressable, with resolved edges, so "what breaks if I change this" is a
  180. single lookup rather than a search. Narrative sections carry Markdown that cites claims
  181. inline with `[[claim-id]]`, rendering each citation as a coloured pip showing that claim's
  182. confidence, so a reader sees which words are load-bearing.
  183. **One document per question.** `auth.docs.json`, `payments.docs.json` — each becomes its
  184. own dashboard entry. Not one document trying to be the whole system.
  185. Pass `--repo` to `dashboard` or every anchored claim renders as unverifiable.
  186. </details>
  187. <details>
  188. <summary><b>Wrong? Fix it from where you found it</b> — the intake loop</summary>
  189. <br>
  190. Every claim and node carries a report link. It opens an issue with a fenced `vibex`
  191. block naming exactly what the reader was looking at, so the request arrives with its
  192. coordinates attached instead of "the auth docs seem wrong".
  193. ```
  194. reader → pre-addressed issue → triage → agent writes a PR → a person merges
  195. ```
  196. - **It answers either way.** Actionable or not, the issue gets a reply and a label
  197. (`ready` or `needs-info`). An intake queue that answers nothing is worse than none.
  198. - **It cannot assert its way out.** The agent follows the same `SKILL.md` you do. What it
  199. could not establish from the code goes in `coverage.out_of_scope`, not into a claim
  200. under somebody's name.
  201. - **It opens, it never merges.** The change arrives as a pull request that has already run
  202. `validate` and `docs --check`. A human still reviews it.
  203. - **No API key? Triage still runs**, still answers on the issue, still labels it. It just
  204. doesn't write anything.
  205. </details>
  206. <details>
  207. <summary><b>Release notes that know what they touched</b> — <code>vibex changelog</code></summary>
  208. <br>
  209. Builds the release list from commit history — and with `--specs`, what each commit did to
  210. the documented system. It becomes a Changes panel in the dashboard, beside the diagrams
  211. those commits moved.
  212. ```bash
  213. vibex changelog HEAD --specs docs/ -o changelog.json --md CHANGES.md
  214. vibex dashboard docs/index.html docs --changelog changelog.json
  215. ```
  216. If the history doesn't use conventional-commit prefixes, sections are inferred from the
  217. files each commit touched — and the output says so, in the document: *"treat the grouping
  218. as a rough sort, not as the author's intent."*
  219. </details>
  220. ---
  221. ## Nothing leaves the machine
  222. An architecture diagram is a reconnaissance map of your system — table names, service
  223. topology, auth boundaries, every internal route. It's the exact thing you can't paste
  224. into someone else's SaaS. So vibeX doesn't have a server.
  225. **There is nothing to review, because there is nowhere for it to go.**
  226. <details>
  227. <summary><b>What the generated file does not do</b> — verified in the source</summary>
  228. <br>
  229. - No `fetch`, `XMLHttpRequest` or WebSocket, anywhere in the viewer runtime
  230. - No CDN, no web fonts, no analytics, no telemetry — the system font stack and nothing else
  231. - PNG export renders through an in-memory blob; it never touches the network
  232. - Pull the cable out of the wall and it still pans, zooms, searches and exports
  233. `vibex host <dir>` writes the nginx + Docker files to serve a folder of pages on your own
  234. box, behind a login that is on by default. Or put it on S3 behind SSO, a private Pages site, a Confluence attachment,
  235. committed next to the code, or `file://`. **No account to view it. No seats. No expiry.**
  236. Hand it to a contractor, an auditor, or the new hire on their first morning. It's a file.
  237. </details>
  238. <details>
  239. <summary><b>Viewer shortcuts</b> — search, deep links, source links, export</summary>
  240. <br>
  241. A PNG of a 40-table schema is a wall. This one you can interrogate:
  242. <kbd>/</kbd> search · <kbd>t</kbd> theme · <kbd>0</kbd> fit · <kbd>+</kbd>/<kbd>-</kbd> zoom · <kbd>r</kbd> reset layout · <kbd>s</kbd> save layout · <kbd>Esc</kbd> clear
  243. Drag any box to move it and its lines re-route around the other boxes. To keep it,
  244. click **Save layout**. The page writes nothing itself; pick one:
  245. 1. **Copy prompt:** paste it to your coding agent. It carries the JSON and the steps.
  246. 2. **Copy JSON:** save it to a file and run `vibex layout <spec.json> <file>`.
  247. 3. **Raise an issue:** prefilled, when `meta.repository.url` is set. Intake applies it in a pull request.
  248. The positions land in the spec's `layout.positions`; every render after that draws the boxes there.
  249. Click any node for its columns, fields, params and relationships. `#node=<id>` deep-links
  250. to one specific table in one specific diagram — so you can send someone *the thing*, not
  251. "it's in the doc somewhere." SVG and PNG export produce standalone files in the current theme.
  252. **Mermaid** exports the diagram as `.mmd`, for Markdown that renders Mermaid (GitHub, GitLab, Notion).
  253. `vibex render` writes the `.mmd` beside every HTML it makes; `vibex mermaid <spec>` prints it.
  254. Set `meta.repository` and `sources: [{path, line}]` and every node links back to the exact
  255. line on GitHub or GitLab.
  256. </details>
  257. <details>
  258. <summary><b>Layout</b> — what lives where, and how to add a diagram type</summary>
  259. <br>
  260. ```
  261. bin/vibex.mjs CLI: validate, render, import, dashboard, docs, changelog, demo, types
  262. schemas/ JSON Schema per type (the authoring contract)
  263. examples/ one example spec per type
  264. renderers/<type>/ JSON -> SVG body
  265. renderers/docs/ claim graph, anchors, markdown export
  266. renderers/shared/ validate, layout (grid, orthogonal routing, edge lanes), svg styles, template, dashboard
  267. importers/ openapi, graphql (own SDL parser), prisma
  268. assets/template.html single-diagram shell; slots are <!-- VIBEX:* --> comments
  269. assets/dashboard.html multi-diagram shell: sidebar, overview, cross-links
  270. assets/viewer.js|css shared viewer runtime, inlined into both shells
  271. assets/icon.svg the mark (monochrome, currentColor)
  272. test/ node:test suite + fixtures
  273. SKILL.md agent instructions (Claude Code / Cursor skill)
  274. ```
  275. A new diagram type is a schema, a validator function, a renderer that emits
  276. `data-node-id` / `data-edge-from|to`, and a line in `renderers/shared/render.mjs`.
  277. </details>
  278. ## Install
  279. ```bash
  280. npx skills add Raja0sama/vibex -g -a claude-code -a codex -y # Claude Code + Codex
  281. ```
  282. ```
  283. /plugin marketplace add Raja0sama/vibex # or, inside Claude Code
  284. /plugin install vibex@vibex
  285. ```
  286. The CLI comes with it and is what the skill drives. If you want it on your `PATH` as
  287. well, or pinned to a published release rather than a clone of `main`:
  288. ```bash
  289. npm i -g @vibex/vibex # adds the `vibex` command
  290. npx @vibex/vibex demo out # or run it once without installing anything
  291. ```
  292. > The unscoped `vibex` on npm is an unrelated package by another author. Always
  293. > install `@vibex/vibex`.
  294. Node 18+. Zero required dependencies. The optional `yaml` package is only needed
  295. if your OpenAPI document is YAML rather than JSON.
  296. <details>
  297. <summary><b>On the roadmap</b> — built for one service, going to a system of them</summary>
  298. <br>
  299. - **Request workflows** — follow one request across service boundaries: the call in, the
  300. services it touches, the events it publishes, the tables it writes. C4 shows what *could*
  301. talk to what; this shows what actually happens when somebody presses buy.
  302. - **Monorepo support** — one repository, many packages, one dashboard. Specs beside the
  303. package they describe, anchors that resolve inside it, and a root view that stitches them
  304. together without anyone maintaining a list by hand.
  305. - ~~**One logical system**~~ — shipped in 0.7 as the System view (`links`, above). Next
  306. for it: which service owns which table.
  307. - **A GitHub Action** that runs in *your* CI, regenerates on every pull request, and comments
  308. what moved — *"2 tables, 3 endpoints."* Still no server.
  309. - **A hosted tier**, for teams who would rather buy the outcome than own the pipeline. The
  310. self-hosted path stays free and stays supported.
  311. These are being designed, not finished. If one of them is the reason you'd adopt this,
  312. [say so](https://github.com/Raja0sama/vibex/issues) — that is the fastest way to influence it.
  313. </details>
  314. ## License
  315. MIT, see [LICENSE](LICENSE).
  316. ### Prior art
  317. Diagrams-as-code is a well-populated field, and vibeX stands on a lot of it:
  318. [Mermaid](https://github.com/mermaid-js/mermaid) and [PlantUML](https://github.com/plantuml/plantuml)
  319. for turning text into a picture, [Structurizr](https://structurizr.com) for treating C4 as a model
  320. rather than a drawing, [DBML](https://github.com/holistics/dbml) for schema-to-ERD,
  321. [Graphviz](https://graphviz.org) for deterministic layout, and
  322. [tt-a1i/archify](https://github.com/tt-a1i/archify) (MIT)
  323. <div align="center">
  324. **Never stale. Never leaves.**
  325. </div>

Ratings and comments

Sign in to rate this skill.

Sign in

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