Archify Review 2026: Architecture Diagrams From Code

What Archify actually does

Archify is an agent skill for Claude Code and Codex. You point it at an idea, a plan, or a codebase, and it produces an interactive architecture diagram. The repository at github.com/tt-a1i/archify shows 91,417 stars, which is a large number for a diagram tool and tells you something about how the Claude Code skill ecosystem has grown. The vendor site is archify.si.

The input surface, as the documentation describes it, covers a GitHub URL, a local path, and infrastructure-as-code files. That last part matters for the question this review keeps returning to: does Archify read real structure, or does it prettify boxes you drew yourself? A tool that parses Terraform, Dockerfiles, and compose files is doing something different from a tool that renders a DSL you typed by hand.

The honest caveat up front: the public documentation is thin. The repository is the better source of truth, and the skill's own instructions are where most of the behavior lives. Where this review describes how something works, it is reading the docs and the repo, not running the tool. Where the docs are silent, that silence is itself a finding, and I say so.

The framing that matters for 2026 is that Archify is not a standalone app you open. It is a skill that runs inside an agent. That changes the cost model, the failure modes, and who it is for. A diagram tool that lives inside Claude Code inherits Claude Code's context window, its file access, and its token bill. It also inherits the agent's ability to read a repo the way a developer would, following imports and config rather than guessing from filenames.

Setup and first diagram: time to value

Installation follows the pattern the Claude Code skill ecosystem has settled on. You add the skill, then invoke it against a target. The repository README walks through the skill install path for both Claude Code and Codex. There is no separate binary to download, no desktop app, no account wall before the first diagram. That is the right call for a tool whose whole value is reading code you already have locally.

What I can say about time to value without inventing a stopwatch number: the first diagram depends almost entirely on how fast your agent can read the repo. For a small project, the skill reads a handful of files and produces output in one pass. For anything larger, the agent has to decide what to read, and that decision is where the minutes go. The docs describe the skill as working from repo structure, which means the agent is doing file traversal and import resolution before it draws anything. That is the correct order, and it is also why the first run on a big repo is slower than the second.

The happy path looks like this: you invoke the skill, the agent reads your entry points and config, and it emits an interactive diagram you can click through. The ugly path is auto-layout. Any tool that generates diagrams from structure has to solve graph layout, and layout is where generated diagrams usually fall apart. Dense dependency graphs produce crossing edges and clusters that overlap. The docs do not promise a layout engine on the level of a dedicated graph library, and I would not expect one from a skill. Expect the structure to be right and the aesthetics to need a pass.

One thing the interactive output buys you that static SVG does not: you can collapse and expand. A generated diagram of a real service is too big to read at once, and interactivity is the difference between a diagram you look at and a diagram you navigate. Whether the interaction is deep enough to replace a proper C4 viewer is a separate question, and the answer is probably no for large systems.

Does it stay in sync with the code?

This is the only question that matters, and it is the one most diagram tools fail. A diagram that is correct on the day you draw it and wrong a month later is worse than no diagram, because people trust it. The failure mode is silent staleness: the picture looks authoritative, the code has moved, and nobody notices until an onboarding session goes sideways.

Archify's architecture sidesteps the worst version of this problem by not storing a diagram as the source of truth. The source of truth is the repo. When you re-run the skill, it reads the code again. That is a full regenerate model, not an incremental one, and for a diagram tool that is the right trade. Incremental diagram updates sound efficient and are a maintenance trap: you end up with a diagram that is half old and half new, and no way to tell which half is which.

The drift behavior you should expect, based on how the skill is described: commit a refactor, re-invoke, and the agent reads the changed files and produces a new diagram. There is no background watcher, no CI hook that I can find in the docs, and no diff view that tells you what changed between runs. That last gap is the real limitation. You get a fresh diagram, but you do not get a changelog. If you want to know what moved, you compare two outputs yourself.

For a solo developer this is fine. You re-run when you need a picture. For a platform team that wants diagrams checked into the repo and updated on every merge, the missing piece is automation. A skill that runs on invocation is not a CI job. You could wire it into a pipeline, but the docs do not describe that path, and I would not assume it works without trying it.

The comparison to hand-written Mermaid is instructive here. A Mermaid diagram in your README is also a full regenerate model in the sense that you rewrite it by hand. The difference is that Mermaid never claims to be derived from code, so nobody expects it to stay current. Archify claims derivation, which raises the bar. If the derivation is good, the staleness problem shrinks to "re-run the skill." If the derivation misses things, you have a diagram that looks derived and is not, which is the worst outcome.

Diagram quality: signal vs box soup

Generated architecture diagrams fail in a predictable way: they show every file as a box and every import as an edge, and the result is unreadable. The skill has to make judgment calls about what counts as a service boundary, what counts as a data flow, and what to leave out. Those judgment calls are where an LLM-driven tool either earns its place or does not.

On service boundaries, the docs describe the skill as identifying services from repo structure. In practice that means it reads your directory layout, your compose files, and your deployment config, and infers where one service ends and another begins. For a repo with clear boundaries, that inference is easy and the output is good. For a repo where boundaries are conventions rather than structure, the inference is a guess, and the diagram will show you the guess. That is not a flaw unique to Archify. It is the fundamental limit of deriving architecture from code, because architecture lives partly in people's heads.

On data flow edges, the quality depends on how much of the flow is visible in the code. HTTP calls between services, queue publishes, and database connections are all discoverable. A flow that happens through a shared database table, or through a config value that names a topic, is harder. Expect the obvious edges and expect to add the subtle ones by hand.

On hiding noise, this is where an agent-driven tool has an advantage over a static parser. A parser shows everything it finds. An agent can decide that a utility module with forty importers is not worth a box. Whether Archify actually exercises that judgment is the thing to check on your own repo, and it is the first thing I would look at.

Against a hand-written Mermaid baseline for the same repo, the trade is clear. Hand-written Mermaid gives you exactly the diagram you intended, at the cost of writing it and maintaining it. Archify gives you a diagram derived from reality, at the cost of accepting the agent's judgment about what matters. For a first draft, the derived diagram wins. For a diagram you will show to stakeholders, you will probably edit the derived output, and the question is whether the output is editable enough to be worth starting from. The interactive format suggests yes, but the docs do not detail an export-to-Mermaid path, so treat that as unconfirmed.

If you want a broader view of which agent tools are worth the setup, the best AI coding tools of 2026 roundup covers the category. Archify is a narrow tool that does one thing, which is usually a better sign than a tool that claims to do everything.

Pricing and limits in 2026

The pricing page lists a starting tier at $0/mo. That is the number that matters most, and it is the right number for a skill. Archify is open source, the repository is public, and the skill itself is free to install. The cost you actually pay is not a subscription. It is the tokens your agent burns reading your repo.

That cost is real and worth sizing. A skill that reads a codebase runs on top of a model, and the model's price per token is what you are really spending. The current snapshot puts frontier models in a wide range. Anthropic's claude-opus-4.1 lists at $15/M input and $75/M output. OpenAI's gpt-5.5-pro lists at $30/M input and $180/M output. On the cheaper end, gpt-5-pro lists at $15/M input and $120/M output. A repo read is mostly input tokens, so the input column is the one to watch. Reading a mid-size repo across many files can add up to a meaningful input bill per run, which is why the second run on the same repo is cheaper in wall-clock time but not necessarily in tokens unless your agent caches context.

There is no per-diagram charge in the pricing the vendor lists, and no export paywall that I can find documented. That is worth flagging precisely because it is unusual. Most diagram tools in 2026 monetize exports, seats, or diagram count. Archify monetizes nothing at the entry tier, which fits an open-source skill and raises the obvious question of how the project sustains itself. The repository's activity is the best signal there, and it is active.

On limits, the docs do not publish a repo size cap or a seat model. The practical limit is your agent's context window and your patience. A repo that does not fit in context will be partially read, and the diagram will reflect the partial read. That is a soft limit, not a hard one, and it is the kind of limit that bites silently. If you are evaluating Archify for a large codebase, the thing to check is whether the skill tells you what it skipped. A tool that reads half your repo and draws a confident diagram of that half is dangerous.

Where it breaks

Monorepos are the first failure case. A monorepo with dozens of packages has no single entry point, and an agent reading it has to choose where to start. The docs do not describe monorepo-specific handling. What you should expect is a diagram that covers the packages the agent happened to read and omits the rest, with no clear signal about which is which. For a monorepo, I would scope the invocation to a single package rather than pointing it at the root.

Polyglot repos are the second. A repo with a Go backend, a TypeScript frontend, and Python scripts has three dependency graphs and three sets of conventions. An agent can read all three, but the service boundaries between them are usually defined by deployment config rather than imports, and the diagram quality drops accordingly. The skill will show you the three clusters. Whether it shows you how they talk is the open question.

Private dependency graphs are the third and the most annoying. If your services depend on internal packages that are not in the repo, the agent cannot see them, and the diagram will show a service with no upstream. That is not wrong, exactly, but it is misleading. The fix is to include the dependency sources in what you point the skill at, which means the tool's accuracy is a function of how much you feed it. That is true of every code-reading tool and worth saying plainly.

The fourth failure case is layout on dense graphs. Auto-layout on a graph with many nodes and cross-cluster edges produces a picture that is technically correct and practically unreadable. The interactive format helps, because you can collapse clusters, but it does not solve the underlying problem. If your architecture is genuinely dense, no auto-layout will save you, and you will end up hand-editing.

One more: the skill inherits the agent's mistakes. If your agent misreads a config file or hallucinates an import, the diagram shows it. There is no validation layer between the agent's reading and the drawing. For a tool whose value is accuracy, that is the risk to weigh. The mitigation is to check the diagram against the code, which is exactly the work the tool was supposed to save you.

Verdict: who should pay

Solo developer documenting a side project: yes. The entry tier is $0/mo, the install is a skill, and the output is a diagram you did not have to draw. For a small repo the agent reads it in one pass and the diagram is close to right. This is the clearest fit.

Platform team onboarding new engineers: conditional yes. A derived diagram of the real system beats a stale wiki page, and re-running the skill after a refactor is cheap in effort. The gap is automation. There is no documented CI path, so someone has to remember to re-run it, and someone always forgets. If your team will actually do that, it works. If not, you are back to silent staleness with extra steps.

Consultant writing proposals: yes, with a caveat. A diagram derived from a client's actual repo is a strong artifact, and it is faster than drawing one by hand. The caveat is that client repos are often private and partial, so the diagram will have holes. Present it as a starting point, not a deliverable.

Large monorepo owner: no, not as-is. Scope it to a package or skip it. The tool's model of reading a repo does not match a repo with no single root, and the docs do not claim otherwise.

Archify is a good tool with a narrow shape. It reads code and draws what it finds, which is the right architecture for a diagram tool in 2026. The weaknesses are the ones that come with the shape: no diff between runs, no CI story, and accuracy that depends on how much of the repo the agent can hold. If those match your constraints, the $0/mo entry makes it an easy yes. If you need diagrams that update themselves on merge, this is not that tool yet.

Beetlix is our own product. Where Archify is a skill that draws from a repo on demand, Beetlix is built around a different workflow, so the comparison is not one-to-one and I would not push it. If you are comparing agent-native tooling more broadly, the AI-native code editors review covers the surrounding category, and the Serena page covers a code-reading tool with overlapping goals.

How this review was researched

Sources for this review: the vendor documentation at archify.si, the official pricing page, the public repository at github.com/tt-a1i/archify (91,417 stars at time of writing), and the live AI model pricing data used to size the token cost of running a skill. No hands-on testing was performed. Claims about behavior are drawn from the documentation and the repository, and where those are silent, this review says so rather than filling the gap.