In practice effort is not the constraint: the reassembly is where the hours go. Sequence reads a repository and hands the structure back as a thing you can point at, services, modules, datastores, topics and the edges between them. On its own tree, scanned on 10 September 2026, that is 1,110 nodes and 2,945 edges, resolved in about five seconds, locally, against your code, with whatever model you attach.
I built it because I could not read a large system quickly and did not want to keep pretending otherwise.
What it is, and whether you can run it
It runs locally against a checkout you already have: no upload, no hosted service, any model you attach. The graph is built from the code rather than described to the model, which is why an agent given it drifts less than one given a summary. On a real scan it maps containment completely and draws one service connector, because that repository has almost no runtime topology to draw.
The part a reader should not have to infer: you can run it. v0.1.0 is on a public mirror, a 179 MiB Windows installer and two macOS builds (the release). It was called CodeForge while I was building it, which is the name you will still find on the older commits. The numbers above were measured on the private tree, so they say how far along this is rather than being something you can yet reproduce.
Visual is the medium, not a feature
An architecture drawn is something you can argue with; the same architecture in paragraphs is homework. Every node carries a kind, service, module, datastore, topic, agent, entry, distinguished without relying on colour, because a diagram that only works if you see hue as I do does not work.
Teaching falls out of that rather than sitting beside it, which is the part I was slowest to understand. Explaining a system and designing one are the same skill pointed in opposite directions: both install a structure in someone’s head and check whether it took. So Teach mode is not a third product but what you get once the design is pinned down in enough formats to re-order it for a learner: take one concept, draw one picture, ask a real comprehension question, withhold the answer until they commit, and reveal it next turn either way.
Two loops decide whether any of this works. An engineer is handed a repository they did not write, runs it locally, and argues with the result, what depends on this, what breaks if I move that, against a model seeing the same graph. And a learner asks a question and gets it drawn part by part, with a question in the middle that finds out whether it landed, which a grader once failed a turn for missing, while the reply was missing the lesson. Neither loop is finished, and I name them because a loop you have named is one you can fail publicly.
Three features I was confident about did not survive measurement
A list of file names carried between turns, so a follow-up question had something to point at, was never used once: fifteen runs with the block moved to three positions, pointed at directly, then instructed outright, and the model named none of the three files only that list could have supplied. A chart tool the model could call whenever a picture would help was proposed zero times across twelve turns, reachable, documented, never reached for. And deleting 2,456 tokens of tool instructions made the model call its tools fifteen times more often, the opposite of what anyone proposed, and it does not transfer to the tier that matters.
Two provisions the model ignores, and one intervention landing on the wrong tier. I would rather have that on a page than shipped quietly.
The distance between working and reaching a screen is where the faults live
A benchmark said teach mode could draw at 12:42. The drawing reached a screen three and a half hours later, and every one of those hours was invisible to every test I had. The same gap explains why the graph is fed to agents as structure rather than described (architecture as a graph).
Design mode took three attempts for a related reason: the capability existed and was unreachable. The prompt saying help the user design a system from scratch was written, and the command line hardcoded it off, the same shape as a --teach flag shipped, documented, and read by nothing. Turning it on was not enough either, two lines of that prompt disagreed, one ordering a clarifying question and one forbidding it, and the model obeyed the wrong one correctly.
The claim underneath Teach mode needed checking, and the checking is the story
Its premise is that the best teaching is interactive and visual, so I had an agent fetch the learning-science evidence with effect sizes read from the papers. It returned twenty sources, then withdrew eight an hour later as never read, and I believed the withdrawal at once, because a retraction sounds like honesty. A third read found every withdrawn number in the papers, verbatim. The correction was the error, and it had already told me not to look.
That is the pattern this project keeps producing, and why I write the failures down rather than the features. The tool exists to stop you holding a system in your head, because a structure you cannot see is one you cannot check. Every finding here is the same thing one level up: something I believed about my own product that stayed believable exactly as long as nobody drew it.