TAO CODINGDocs /
The Architecture tab
The Architecture tab in the right panel shows a diagram of the project the
focused pane is in, drawn with archify.
Click any box to see a short description of what that part does; click the
background or press Esc to close it. Zoom is archify's own control at the
bottom of the diagram.
Agent activity. The tab can show where agents are working: while a
Claude Code, Codex, Qwen, Gemini, Cursor, GitHub Copilot, Kimi Code,
OpenCode, OMP or Antigravity (experimental) pane edits a file, the box
that owns it pulses in that pane's colour (the same colour it has in the
Meeting Room), and settles a few seconds after the edit. This needs small edit
hooks in those CLIs' own settings — TAO CODING only adds them when you press
Enable on the tab's banner (or leave the checkbox on when generating a
diagram). They send only file paths, never contents, and only to TAO CODING
on this machine; panes started outside TAO CODING are ignored. Agents
already running pick the hooks up after a restart. Codex also asks you to
approve the hook the first time it runs it (and again after TAO CODING is
moved or updated) — TAO CODING never approves it on your behalf. Cursor
rides on Claude Code's own hook (it runs the same hook protocol), so
enabling Claude Code covers Cursor too — there is no separate Cursor entry,
and the Claude Code entry is offered even when only cursor-agent is installed.
TAO CODING keeps its own hook and plugin files current: it rewrites them at
the next launch if they were hand-edited or the app moved (they carry
TAO CODING's name and, for the plugin files, a marker line); it never adds
them to a CLI where you did not, and any hooks or files of your own are
left alone. Remove hooks at the bottom of the tab takes them out again.
The files are ~/.claude/settings.json, ~/.codex/config.toml,
~/.qwen/settings.json, ~/.gemini/settings.json,
~/.copilot/hooks/taocoding.json, ~/.kimi-code/config.toml and
~/.gemini/config/hooks.json for Antigravity (a separate file from Gemini
CLI's own settings). OpenCode and OMP instead get a small plugin file
that TAO CODING writes and removes with the others.
The diagram lives in the project, in .taocoding/architecture.json and
.taocoding/architecture.html, so it opens instantly and can be committed
for your team. The tab shows the diagram alone, filling the panel on the
app's own background and VS Code colours (drawn portrait so it suits the tall panel; its zoom
buttons stay). A pane inside a git worktree shows the main checkout's
diagram. When the project has no diagram yet (or its file is broken), the tab offers
to generate one: pick an installed agent and press Generate. TAO CODING
starts that agent in a hidden pane, with a short brief in
.taocoding/architecture.prompt.md, and the tab shows its progress instead;
if the agent stops to ask something (a permission prompt, say), the tab
tells you so. The agent reads the repository and
draws the diagram with the bundled archify tool, which needs Node 18 or
newer — the card warns when TAO CODING can't find it, though an nvm/fnm-managed
Node in your shell still works. This uses the agent's
tokens and usually takes a few minutes. When the agent stops, TAO CODING
checks its draft. If something is wrong it sends the problems back to the
same pane, up to three attempts in total, and then shows them in the tab
with a Retry button. Show terminal brings the agent's pane into
view (so does picking it in the navbar's workspace tree); Check now
re-checks when an agent's state can't be detected; Stop watching leaves
the pane alone and returns the tab to its card. Only one diagram is generated at a time; while one runs for another project, Generate is disabled.
Keeping the diagram current. While you and your agents work, TAO CODING tracks which parts of the system change. When the tab loads, after an update, or a couple of seconds after an agent stops, the stale bar appears at the top showing changes: amber dashed outlines around the boxes whose files changed, and a count of "X areas changed · Y files not in the diagram". Diagrams generated or updated from the tab are tracked automatically. For diagrams made before this version (with no stored fingerprints), a Track changes button appears; press it once to record the current state. Git is required for change tracking; in a non-git folder the bar shows "Change tracking needs git."
If the diagram is stale, the Update button asks the agent to revise only the changed areas, starting from the current diagram and keeping the other boxes as they are. When nothing is stale (or changes aren't tracked, or the project has no git), Update is still there: it asks the agent to re-check every box and arrow against the code, keeping the ids and layout — a manual refresh without turning Auto-update on. Right after an update, the bar briefly shows "Checking for changes…", and both Track changes and the Auto-update checkbox are disabled while a diagram is being generated or updated. Update reuses the previous agent pane only when it is idle, still running its agent, and you aren't typing in it; otherwise it opens a new hidden pane in the active workspace. The Regenerate suggestion appears when more than 40% of the diagram is stale. Both changes require the agent's tokens.
Auto-update is an optional setting, off by default, stored in the project's architecture.json alongside your diagram. It is kept across updates and regenerations. When it is on, TAO CODING runs an update about a minute after all agents stop, but only when diagram areas have changed — files that aren't in the diagram (READMEs, lockfiles) never trigger it. Once an update runs, it won't run again until an agent stops again. Only agents working in this project (its folder or its worktrees) count, it waits while you're typing in any pane, and it opens its hidden pane in a workspace that already has a pane on this project — with no such workspace it doesn't run. After a failed auto-update it waits until the changed files change again. Each update counts against your tokens, the same as a manual Update. Because the setting travels with the repository, a project whose file already has Auto-update on stays paused on each launch until you click Resume for this session — a cloned repo never spends your tokens without a click on your machine.
New projects: design before coding
When you start a project from an empty folder (nothing but a README, docs or other Markdown), the agent you are planning with draws the design before it writes any code. Once you and the agent agree on a plan, it draws two diagrams and TAO CODING opens the Architecture tab to show them:
- Flow (the first sub-tab): what the app does step by step — the order, the branches, what happens on errors.
- Blocks (the second): which parts the app is made of and how they talk to each other — the same kind of diagram as for an existing project. Every box starts with a grey dashed outline: it is planned, with no code yet.
Review them and answer in the same chat: ask for changes and the agent redraws them, or agree and it starts coding. There are no buttons to press in the tab. As the code for a box appears, its grey outline goes away; from then on the box is tracked like any other (see Keeping the diagram current). Auto-update never runs while any box is still planned — the app is still being built. The Flow isn't tied to files, so it doesn't update by itself: the agent updates it when a change alters the app's logic.
This works with agents connected to TAO CODING's tools (Claude Code, Codex, Qwen, Gemini and the others TAO CODING registers). The rule reaches them on its own; if an agent skips it, press Design first on the tab's card to ask the focused agent. TAO CODING cannot stop an agent from writing code first — the rule is guidance, not a lock. Projects that already have code keep the regular Generate card.