Archify: the agent that maps your project's architecture into verified diagrams

Not every project has an architecture diagram. If one ever existed, it was drawn long ago, abandoned, and the project has moved far past it since. And if the project was vibe-coded, there never was a diagram: services, integrations and webhooks appeared one prompt at a time, and a couple of months later digging in yourself to work out what lives where and what talks to what is hard and confusing, because there is simply too much of it.

That is what Archify is for. It is not a diagram editor but a skill for an agent: Claude Code, Cursor or Codex explore the repository themselves, find the components and the links between them, draw the diagram and run nine checks on it before showing it to you. If an arrow cuts through an unrelated node or a label lands on a neighbouring line, the agent sees it before you do and fixes it.

For a vibe-coded project it is the first chance to see what you actually built and to re-check the architecture before it grows further. For a project that has lived with you for years it is a way to open your eyes to how it looks as a whole, rather than from memory.

We installed it in the morning and by lunch had diagrams of our own project that we were not embarrassed to show. Below are two examples, both drawn by Claude Code from a one- or two-sentence description.

What it actually is

There are three things inside. An instruction file for the agent: how to pick a diagram type, which fields nodes and links carry, in what order to check the result. Five data schemas, one per diagram type. And a Node renderer that takes the JSON and assembles a single HTML file with SVG inside, no server, no external dependencies.

There are five types, and the agent picks between them from the wording of the request:

• Architecture: components, storage, external services, boundaries such as "this lives in the cloud".
• Workflow: processes in lanes and steps, approvals, CI/CD, runbooks.
• Sequence: who sent what to whom and what came back.
• Data flow: pipelines, sources, transforms, consumers.
• Lifecycle: states and transitions, waits, retries, terminal exits.

Every node is typed: frontend, backend, database, cloud, security, message bus or external service. The renderer takes colour and icon from the type, and the legend at the bottom assembles itself.

One command to install, then ask in words

npx skills add tt-a1i/archify -g
# check that everything is in place
node ~/.claude/skills/archify/bin/archify.mjs doctor

The install drops the skill folder next to your other skills; Cursor and Codex have their own flags. Nothing changes inside your repository, no dependencies to install. From there the conversation is in words. It works without a repository, from a description:

Use Archify to draw: Browser -> API -> Redis cache -> PostgreSQL fallback.

And with a repository, when the diagram has to reflect real code:

Analyze this repository, then use archify to create a high-level runtime architecture diagram. Show 8–12 core components, one primary path, external dependencies, and trust boundaries.

After the first version you refine: "add a queue", "highlight the rollback path", "drop analytics". The agent edits the diagram, re-checks and hands back a new file.

Nine checks before you see the result

This is what separates Archify from "ask a model to draw it". Before delivery every diagram goes through a validator: structure, layout, HTML and SVG, arrow routes, clearance between labels and lines. In showcase mode there are nine such checks, and while any of them is red the instruction forbids the agent from calling the result done.

Errors arrive not as "something is off" but as a rule code and a list of fixes: "the label overlaps a node, move it or set an anchor", "the line runs along a box border, cross it perpendicularly", "two arrows share one corridor, separate them". None of these stop the picture from looking decent, and that is exactly what the eye skips.

Our first architecture draft came back with six remarks and the repair took three rounds: move one node, shorten one label, hand one route to the automatic router. That is normal, and the instruction explicitly tells the agent to fix only what the diagnostic points at, and to stop if two consecutive rounds do not improve the count. The diagram does not turn into a tangle of manual detours after edits, because coordinates exist only on nodes and the routes are computed by the compiler.

What you get at the end

Not a picture but an HTML page, and it has things a static PNG cannot. At the top, a panel of "chapters": the agent describes three to five stories such as "customer request", "cache and search", "orders and mail", and the Play story button walks through them in turn, highlighting the relevant nodes. There is node search, route tracing between two points, presentation mode, and a one-button switch between dark and light themes.

Export lives in the same page: PNG to the clipboard with one button, SVG for documentation, WebM if trace motion is enabled, and a 1200×630 share card for social media. The card is not abstract: it is captured after you trace a specific path and shows that path against the whole diagram.

From the code, not from memory

Two capabilities worth keeping Archify next to the repository for. First: an architecture node can carry a SRC badge that opens a file and line range at a specific commit. The diagram stops being a claim of "we think it works like this" and becomes a link saying "here is the code". Second: the compare command takes two versions of a diagram and builds a delta page: what was added, what disappeared, what moved. For a review of "we split the queue into its own service" it is exactly the artifact you want attached to the pull request.

What it costs

Nothing. The licence is MIT, the project grew out of Cocoon-AI's architecture diagram generator, also MIT, and says so honestly in the instruction header. There are no paid plans, hosting or accounts: everything you get sits in your folder and opens with a double click.

As of 4 September 2026 the repository has 47,000 stars, 24,000 of them from the last week: the fastest-growing project of the week on GitHub. Version 2.17, commits land daily.

Who I recommend it to, and who not

Recommended if you have a project whose structure you have explained in words at least once: to a new developer, a client, or yourself six months later. One evening, and you have diagrams assembled from the code, checked by a validator, and refreshed with the same command when the code changes. Especially recommended to anyone writing documentation or articles: PNG export and the dark theme settle the illustration question.

Not recommended in two cases. If you need a board where a diagram is moved by hand on a call, that is Figma, Excalidraw or tldraw; Archify has no such mode on purpose. And if you work without an agent at all: you can write the JSON by hand, but then you get the validator without the part the whole thing was invented for.