Every change the AI plans, makes, or breaks — projected onto a living map of your system.
The hard part of AI-assisted development is no longer generating code — it’s understanding, verifying, and steering what the AI did. Flow’s Blueprint shows you every architecture change on a living map of your system, while the workflow underneath keeps the code itself at quality — verified, reviewed, and committed one task at a time.
Components the plan predicts appear on your system map as dashed ghost nodes. Confirmation is mechanical, never narrated — a ghost turns solid only when a derive finds the real thing in code. The AI cannot claim it built something.
Scrub the plan phase by phase and watch MODIFIED / ADDED badges land on the modules each phase touches. Review blast radius before approving execution, not after the diff exists.
Every plan narrates its concept arc — problem, shape, data flow, decisions, risks — compiled against the map with strict resolution: a story cannot reference a component that does not exist or is not legitimately predicted.
A worker saying "done" is never the evidence. Every task's verify command re-runs independently; failures get a diagnosis sub-agent and a bounded repair loop; every task commits atomically so history matches the plan.
Content-hash baselines catch every gap between the map and reality — a teammate's merge, an agent's edit, your own late-night patch. Baselines advance only when you acknowledge a review, never silently.
Knowledge attaches to the map only through anchored execution records carrying their run id. Docs found in the repo are treated as unverified claims until corroborated against code — a built-in doc-rot radar.
Follow one feature — usage-based billing — through Flow, on a 27-component platform. Every frame below is the actual product, cropped to what matters.
This is what AI-assisted development actually hands you: billing/proration.ts, payments/webhooks.ts, gateway/rate-limit.ts, two SQL migrations, dunning workers, invoice emails — twenty-six files across nine parts of the system, in one turn.
A diff can tell you what each line became. It cannot tell you what the change means — what talks to what now, which module quietly gained a dependency on Stripe, whether the webhook handler and the retry logic agree. Nobody holds that in their head at review time.
The Blueprint is derived from the code — 14 modules, the exposed API surface (POST /v1/checkout, POST /webhooks/stripe…), three datastores, six external integrations, and every wire between them. And look closer: the amber counters ARE the files from act one, already grouped by module — 5 on payments, 6 on billing, 3 on gateway. The wall from the review list has landed on the architecture, and every touched module carries a learning dot: its knowledge is already here. Rebuilt on every derive, so it cannot rot. (Act five turns this layer into the review itself.)
This is what Flow actually knows about payments — a real, reviewable document: the module’s purpose (“nothing else talks to Stripe directly”), its key flows traced end-to-end (charge → webhook invoice.paid → invoice email; dunning with capped backoff), its invariants verified against code — every Stripe write carries an idempotency key — and a file-by-file map.
The footer is the guarantee: verified against 5 files, re-learns automatically on drift. Hash-stamped against the exact code it describes, flagged stale the moment that code moves — knowledge that cannot silently lie.
And it’s why Flow is cheap where other agents are expensive: instead of re-reading hundreds of files every turn, the agent pulls this indexed, capped context — a module answers in ~1,500 tokens, not a directory crawl. Structure is indexed once and hash-gated; expensive understanding is written down, verified, and reused. Fewer tokens in, sharper answers out — on turn one and on turn two hundred.
Every learned doc is hash-stamped against the exact files it describes. The moment web’s code moves, its doc is flagged STALE and re-learns — no silently outdated understanding, ever.
And not everything in a repo deserves the same trust. Flow ranks its sources in tiers: code is ground truth; Flow’s own verified store comes next; a README, wiki page, or diagram someone dropped in the repo is just a claim — read, then adjudicated against the code the learn pass actually opened. A doc the code contradicts is marked contradicted and never overrides what the code says. Agents that trust every file equally get confidently misled; Flow doesn’t.
Before executing, the plan plays as a phase-by-phase walkthrough on the board — phase 1 meters usage at the gateway, phase 2 turns counters into Stripe invoices — with MODIFIED badges landing on exactly the modules each phase touches. And the walkthrough isn’t sealed off from the code: click any file in the phase module’s Files tab and it opens right there, in a drawer on the same screen.
Open the Blueprint with uncommitted changes and the changeset is already on the map — “23 changed files” in the header, every touched module lit with its count, everything untouched faded. Click payments and its Changes tab leads: five files, three already approved, each ✓ writing real git staging (approval and staging are one state, on the map and in the list), each ✕ sending the file back to the agent with your feedback.
And the knowledge from act three is no longer just documentation — it reviews with you. A background checker reads each touched module’s learned invariants against its changed hunks and raises what it finds, right under the file list.
The findings are amber, not red, on purpose. They never gate the ✓ — you can approve a flagged file the moment you’ve judged the warning. A module without learned invariants says so honestly (“no invariants learned yet”), and verdicts are cached by content hash: an unchanged review costs zero tokens.
This is the join the flat diff list can’t make: these files changed, this module owns them, and here is what the system knows about that module — answered in one click, on the map, at the moment you decide.
This IDE is developed inside itself. Its features are brainstormed, discovered, planned, executed phase-by-phase with independent verification, reviewed, and shipped — by the same workflow it gives you. Even its release notes are written by the agent from the real commit history, then held at a human gate before anything publishes. When an update lands in your copy of Flow, you’re reading the system describing itself.
It builds the structures that make trust unnecessary.