I ran 3 Claude Code architecture diagram tools on my repo. Here's what each one got right

My project, worklore, is a small app that grew in all directions: a Python backend on AWS Lambda, a plain-JS site, an MCP connector for agents, and four more repos around it. I wanted a picture of it I could trust. So in one day I ran three open-source tools that turn code into a diagram or a map, all three as plugins for Claude Code:

• Floorplan: a map of the app with its parts, endpoints and user flows.
• Archify: one architecture diagram, every box linked to the exact lines of code.
• Understand Anything: a knowledge graph of every file, function and class, with a guided tour.

Floorplan's README has a nice table comparing the three. It says what each tool answers and who it's for. It has no time, no cost and no pictures of the other two. This post fills that in, on one real codebase, and then does the test I actually care about: can each one answer real questions about my own code?

The short version

Floorplan: the map is right, the flows were not

Floorplan read my 166 files and drew them as parts with plain-words descriptions. The first surprise: it found 0 endpoints. My server keeps its routes in one table keyed by "METHOD /path", not in a framework router. I opened a pull request to read that shape, and the author merged it 70 minutes later. Then it showed all 66.

The real trap was the user flows. While building the map, the agent also wrote flows, and it wrote them from its memory of my app. One said a person can publish a story from the website. The site can't do that. Another got wrong how a story gets drafted for someone else. A wrong flow and a right one look the same on the map.

What fixed it was a button Floorplan already has: Request a new flow. You describe a flow in plain words, and the agent traces it through the code, tying every step to a route or a function. I deleted the hand-written flows and requested 17. Then I ran 16 of them against a staging copy of my backend: 14 work, one partly, one can't be tested there. The 17th, a nightly job on my Mac, had been quietly failing for two nights.

I wrote it up step by step, so your agent can redo it on your app: My agent drew my app's user flows from memory and got two wrong; Floorplan's traced ones were right.

Archify: one diagram for five repos

Archify draws from a JSON description and then checks it hard: every cited line must exist at the pinned commit, and the last check opens the diagram in a real browser. What its docs don't say up front: a diagram pins exactly one repository. My project lives in five, and the links between them aren't code at all. One repo is a skill that tells an agent to call my API with curl; another is a scanner my server keeps a copy of. A tool that follows imports sees five islands.

So I pinned the repo where the system runs, linked its boxes to lines of code, and drew the other repos as named boxes with a card saying what each holds. Two runs failed first: my SSH remote was rejected for web links (the HTTPS form works), and my uncommitted edits shifted line numbers away from the committed bytes Archify checks against.

Archify proves the cited lines exist. It does not prove what a card says. One of mine, "how stories get written", was wrong twice, again from my agent's memory. The full recipe: One architecture diagram for a project split across five repos, with Archify.

Understand Anything: the most thorough, the most expensive

I ran Understand Anything headless, so I got exact numbers: 14 minutes, 16 helper agents working in batches of five, and $13.01 at API list prices (on a Claude subscription it comes out of your plan instead). Its README warns that the first run uses a lot of tokens. It does.

What you get is a lot: 732 nodes (files, functions, classes, config, docs), 1,625 links, 9 layers, and a 15-step tour that starts at the README and walks through the code in a sensible order. Every function has a one-line summary. I checked the summaries in the places where my agent had been wrong from memory, and they were right.

Two things to know before installing it. Its start-of-session hook tells the agent to rebuild a stale graph and "Do not ask the user for confirmation" (only if you turn auto-update on). And its dashboard runs as a local server; in a headless run it died after 10 minutes, when Claude Code stops background jobs.

It feels made for someone else's project: the tour and the summaries teach you a codebase you've never seen.

The real test: three questions about my own code

Pictures are nice. What I wanted was answers. I asked each tool the same three questions, the kind I'd ask before changing anything:

1. How do we decide whether a person has enough rights for an action, in the MCP connector and in the REST API?
2. What numbers do we keep about reproductions and other actions, including anonymous ones?
3. What do we log, and where?

Floorplan got them in its Ask bar, Understand Anything in its chat command, and for Archify an agent that could see only the diagram. Then a plain agent with no map at all read the code to make an answer key.

Nobody made anything up, which already beats my agent's memory. But look at how they got there. Floorplan's Ask reads the map and the code, by design. Understand Anything's chat is meant to answer from the graph, yet it opened the source files anyway and said so. Archify has no way to answer questions, and the diagram simply doesn't hold this level of detail.

And the plain agent reading code found things none of the three did. The biggest was a security hole. When an AI app connects to worklore through OAuth, the sign-in advertised two permissions, worklore.read and worklore.write. The code never checked them. The app got an ordinary account pass, and that pass also worked on the site's REST API: it could delete my stories, change their visibility, and, since I'm the admin, open the admin pages. All three maps described the sign-in correctly, as a flow. None of them asked what the token could reach once issued, because that isn't a box or an arrow.

I fixed it before publishing this. An app's pass is now marked as one, works only through the connector, and only within what you approved; an app that asks only to read can't write. A new test walks the whole OAuth flow and then tries the pass on every kind of route.

The same agent found more places where my code and my own documents disagreed. My privacy page left out Google sign-in, described "standard server logs" with IPs that my application doesn't write (the CDN logs do, for 14 days), and called my analytics page-views-only when the server also sends events, some with the caller's IP, and the site sends the text of searches that find nothing. Smaller ones: a doc that says a log field holds a raw id when the code hashes it, a counter that also counts HEAD requests, agent reads over MCP that never count as reads, and staging logs that were kept forever (now 90 days, like production). I rewrote the privacy page against the code; the rest of the smaller ones are on my list. None of it is "architecture", so no map shows it.

So which one should you use?

• You inherited a codebase, or you're about to contribute to someone else's: Understand Anything. The tour and the per-function summaries are the fastest way in, if the token bill is fine.
• You own a small app and want to know what users can actually do: Floorplan, but delete every flow it wrote while building the map and request them again, so each step is traced to code. Then test them.
• You need one picture for a README, a pitch or a new teammate: Archify. It's the only one whose output is a single, checked diagram you can share. Check the cards yourself.
• You need to know whether your code keeps your promises: none of them. Ask an agent to read the code with that exact question.

The one habit that works with all three: before trusting a map, ask it three questions you already know the answers to. It takes two minutes and tells you which parts were traced and which were remembered.

Both write-ups above are on worklore as stories your agent can redo: what I tried, what failed, the exact steps, and how to check it worked. If you run either one on your own repo, the story page shows whether it worked for other people too.