/visionaire:startWorks on what you already have. Reads your codebase before recommending anything.
Translates your UI/UX decisions into technical structure — components, data model, technology choices, and integration points — before a line of implementation begins.
None of this is theoretical. These are the patterns that show up every time.
The Architecture phase reads your existing codebase before recommending anything. For greenfield projects, it designs the system from the experience outward. For existing systems, it understands what's already there — and places new capabilities correctly inside it, not bolted on from outside.
One undocumented architectural decision costs 6–10 weeks of implementation rework. Architecture Phase catches them all before the first file is created.
The Architecture Phase takes every screen, interaction, and constraint from UIUX.md and maps it to components, data, technology choices, and integration points — without writing a line of code.
Your UX spec. Your existing codebase, if there is one. Architecture decisions that aren't grounded in what you've already built become technical debt before the first feature ships.
One architectural pivot costs 6–10 weeks. This phase costs $297.
Start my spec session — $297Two mandatory checkpoints where the agent stops and waits before proceeding. You don't commit to structure until you've confirmed what was understood.
The agent reads UIUX.md and BRIEF.md, then presents a structured summary of technical implications: real-time needs, data requirements, performance constraints, and any UX elements that carry architectural weight. You confirm or correct. Nothing proceeds until you confirm the agent understood correctly.
One question at a time across seven areas: technology stack, system boundaries, data architecture, external integrations, security model, scale expectations, and deployment approach. Questions adapt based on your answers. You stay in control of every technology decision.
After the interview, the agent runs a UX gap check against UIUX.md, then generates an architecture outline. You approve the structure — components, data model, technology stack, integration points — before a single page of detail is written. Structural misalignment is caught here.
The full document is written from the approved outline. An autonomous stage gate reviewer then evaluates it against eight criteria — anchored on the User Journey Infrastructure Requirements section, which every other decision must trace back to. APPROVED or REJECTED. Features phase begins only on APPROVED.
Architecture has a formal quality-gate reviewer. Unlike the Idea Phase, Architecture cannot self-certify readiness. An autonomous critic evaluates ARCHITECTURE.md before advancing. A document missing rationale, unclear on component ownership, or silent on security will be REJECTED — and the specific gaps will be named. Every other phase (Product Brief, UI/UX, Features) also has a gate.
Not an idealized clean-slate project. Architecture Phase works differently depending on what you're starting from — here's what that looks like.
Everyone agrees on Rails. Nobody agrees on where business logic lives, how authorization works, or whether the real-time features need Action Cable or a separate WebSocket server. You're about to start building with six different mental models of how the system is structured.
The technical interview forces each question into the open, one at a time. By the end, technology preferences are captured as documented decisions with rationale — not tribal knowledge held in different engineers' heads. The outline shows you what you agreed on before anyone starts building.
An ARCHITECTURE.md that documents component ownership, technology choices with rationale, and explicit boundaries between parts of the system — before the first line is written and before disagreements become undocumented code.
ScopeGuard is live. Sarah Chen wants to add real-time scope change notifications — a fundamentally different interaction model than the current request/response pattern. The existing architecture wasn't designed for it, but a full rewrite isn't on the table.
Architecture Phase can be run against an existing codebase. The agent reads your current system structure before asking technical questions — understanding what constraints already exist, what can be extended, and where the new capability fits without creating a seam that users will feel.
An architecture document that shows exactly how the new capability integrates with the existing system — what changes, what stays, and why — ready for feature specification without guessing at constraints.
UIUX.md came back with offline capability, sub-300ms search, and a collaborative editing mode. None of these were in the original technical thinking. Features that seemed simple suddenly require IndexedDB, full-text search infrastructure, and WebSocket conflict resolution — decisions with real tradeoffs nobody has surfaced yet.
The UX comprehension review at the start of Architecture Phase is specifically designed for this. The agent reads UIUX.md and maps every requirement to its technical implication, then brings those implications into the interview as explicit questions — before they become implicit assumptions in a Features spec.
Technology decisions made for the system you're actually building — not the simpler one you originally imagined — with every UX requirement accounted for before Features begins.
After UI/UX validates the experience. Before Features specify what gets implemented. The point where thinking becomes structure.
Teams do it constantly. "We'll figure out the architecture as we build" is a decision — it just happens in code under pressure instead of in a document under deliberation.
Architecture doesn't slow you down. It changes what Features is working with.
Features written from a documented architecture move faster and produce cleaner implementations than features written against an architecture that exists only in someone's head. The hours spent here aren't overhead — they're the decisions that determine whether implementation is clear or chaotic.
Every project that skips this phase has architecture. It just wasn't designed — it was discovered.
Discovered architecture inherits every assumption that came first. The engineer who touched it first. The deadline that was looming. The framework default that nobody questioned. Architecture Phase exists to make those decisions explicit before any of those pressures show up.
The architecture interview doesn't ask you to fill out a form. It asks you questions you haven't been forced to answer yet — in the order that your UX decisions demand them. That sequencing is the work.
Every technology choice you leave implicit becomes a constraint the next engineer works around without knowing why. Every undefined component boundary becomes business logic that lives where it shouldn't. This phase closes those gaps before implementation inherits them.
— Robert EvansReads your codebase before recommending anything. No mid-build technology debates. No architectural surprises three weeks into implementation. Every decision made before the first file is created — and documented so anyone can question it later.