For most practices, AI in architecture still means one thing: a button you press near the end. The model is done, the scheme is decided, and you reach for a renderer to turn it into something a client can read. That's where AI entered the workflow, and for a lot of studios it never moved. It's the cheapest place to bolt it on and the easiest place to see the result.
A piece in Architect Magazine this month makes the case that this framing is already behind the curve. Its argument, in the headline's own words, is that AI is redefining archviz workflows, turning visualization into an integrated tool for design thinking, not just rendering. Read quickly, that sounds like marketing. Read carefully, it's a claim about where in the process the machine is useful, and that's the part worth taking seriously, because it relocates the value.
The render button is the shallow end
Start with what the render-stage tools actually do. An image-based renderer, whether it's a Veras-style plugin or a Midjourney workflow, takes something you've already designed and makes it look finished. That's genuinely useful. It compresses days of visualization into minutes, and it's the reason most architects met AI in the first place. But notice what it doesn't touch: the design. By the time the renderer runs, the massing is set, the plan is frozen, the decisions that mattered have all been made. The AI is a stylist, not a collaborator.
That's the render-only mindset, and its limit is structural. It can only ever improve the presentation of a scheme you arrived at by hand. The hours where the project was genuinely open, where you were testing whether to go five storeys or six, whether the units fit, whether the site even supports the program, the AI was nowhere near. Those are the expensive hours. Those are the hours that decide whether the building is any good. And that's exactly the territory the Architect Magazine piece is pointing at when it talks about design thinking rather than rendering.
The renderer makes the answer look good. The interesting tools help you find a better answer.
What design-stage AI actually does
The category that lives upstream is different in kind, not degree. These tools operate on the design itself rather than its image. Three names anchor the conversation, and they're worth separating because they're not interchangeable.
Autodesk Forma (the planning environment that grew out of Spacemaker) works at the site and early-massing stage. Its pitch is real-time analysis while you shape volumes: sun hours, daylight potential, wind, noise, surrounding context, the environmental constraints that should shape massing but usually get checked too late to change anything. Autodesk positions it as AI-assisted conceptual design, where you draw a massing and the consequences show up immediately instead of three weeks later in a consultant's report.
Finch works at the generative-layout level, growing and adapting plan options against rules and constraints, so you can see how a change ripples through a scheme rather than redrawing it. TestFit is the feasibility specialist, strongest on multifamily and parking, where it solves unit mixes, layouts, and yield against a site and a program in real time, the brutal arithmetic that decides whether a deal pencils before anyone draws a nice elevation.
These tools intervene before the scheme is fixed. Forma analyzes site and massing (sun, wind, daylight, noise) as you draw; Finch generates and adapts plan layouts against constraints; TestFit solves feasibility and yield for multifamily and parking in real time. None of them produces the hero image, that's the renderer's job, but all of them change what you decide to build, which the renderer never does.
Notice the through-line. None of these outputs a beautiful picture as the point. They output options and consequences: this massing costs you that much daylight, this unit mix yields this many homes, this layout breaks if the corridor moves. That's design thinking made cheaper, not rendering made faster. It's a different bet on where the machine earns its keep.
Render-stage versus design-stage, side by side
| Dimension | Render-stage AI | Design-stage AI |
|---|---|---|
| When it enters | After the design is decided | While the design is still open |
| What it changes | The presentation | The scheme itself |
| Core output | A finished image | Options, metrics, trade-offs |
| Example tools | Veras, Midjourney, image renderers | Forma, Finch, TestFit |
| Question it answers | How does it look? | What should we build? |
| Where it shines | Client-ready visuals, fast | Constrained, quantifiable sites |
| Honest limit | Can't improve a bad scheme | Optimizes only what you measure |
The table isn't a verdict that one category beats the other. They sit at different ends of the same process and a serious practice will run both. The point is that most studios have adopted only the right-hand column's image and skipped its thinking, and the left column is most of their AI footprint. The render-only mindset isn't wrong, it's just shallow. It harvests the easy minutes and leaves the expensive hours untouched.
What this means for how a practice works
If you take the upstream shift seriously, the change isn't a new tool in the stack, it's a change in when you bring the machine in. Concretely:
- Feasibility moves to day one. On a multifamily or mixed-use site, a tool like TestFit lets you test whether the program fits before you commit a week of hand-drawn study. The yield question gets answered while it can still change the brief.
- Analysis stops being a gate and becomes a dial. With Forma, sun and wind aren't a consultant's verdict delivered after the massing is locked; they're a live readout as you push the volume around. The constraint shapes the design instead of vetoing it.
- Option count goes up, redraw cost goes down. Generative layout tools like Finch make it cheap to carry five live schemes instead of nervously committing to one. The bottleneck shifts from producing options to judging them, which is exactly where you want an architect's time to go.
That last point is the real reframe. The render-only studio uses AI to do less drawing at the end. The upstream studio uses AI to do more exploring at the start, and then still reaches for a renderer to communicate the chosen scheme. The renderer doesn't go away. It just stops being the only place the machine shows up.
What's real, and what's hype
Honesty demands separating the two, because the vendor framing flattens them. The real part: feasibility and analysis tools genuinely do work that used to take days, and on constrained, quantifiable sites, especially housing, that work directly shapes the design. That's not a demo trick. Yield, daylight, and layout are numbers, and software is good at numbers.
The hype is the implication that this is finished, universal, and automatic. It isn't. TestFit is sharp on multifamily and parking and largely beside the point on a bespoke cultural building. Forma's analysis is only as good as the questions you think to ask of it. Generative layout tools optimize against the constraints you give them, which means they're blind to the ones you forgot to encode, and a building is mostly the constraints nobody wrote down. None of these tools holds the client relationship, carries the design responsibility, or knows which trade-off is the right one. They widen the option space; they don't have taste.
So the upstream shift is real but uneven. It's strongest exactly where the problem is quantifiable and weakest where the value is qualitative, which is to say it helps most with the parts of architecture that were always the most measurable, and least with the parts that make a building worth caring about. That's a meaningful tool, not a replacement for judgment.
Our take: the render-only mindset is leaving value on the table
Here's the opinionated version. If your entire AI footprint is a render button at the end of the process, you've adopted the least valuable part of what's available and called it transformation. The pretty picture is the easy win, and easy wins are, almost by definition, the ones your competitors also have. There's no edge in being able to render fast in 2026; everyone can.
The edge, if there is one, is upstream, in being able to test more options, catch feasibility problems before they cost you, and shape massing against real constraints while the design is still soft. That's harder, less glamorous, and it doesn't produce a screenshot for the firm's Instagram. It also happens to be where the expensive decisions live. The Architect Magazine framing, visualization as design thinking rather than rendering, is really an argument about not stopping at the shallow end.
We'd put it bluntly: treat the renderer as the last 10% of where AI helps, not the whole of it. The practices that get the most from this shift won't be the ones with the prettiest renders. They'll be the ones who moved the machine earlier, used it to explore instead of just to finish, and kept their own judgment firmly in the seat where the trade-offs get decided. The tool got smarter. The question of what to build is still yours, the upstream tools just let you ask it more times before you commit.
If you're starting next week
Pick the one project on your board with the most quantifiable constraints, a housing site, a tight infill, anything yield-driven, and run a feasibility pass before you draw. Notice how many assumptions it forces into the open early. Then keep your renderer for the end, where it belongs, and resist the urge to call that part the strategy.
We test where AI actually earns its place in a real practice, from feasibility to final image, and publish the honest version. Join the studio newsletter for weekly field notes on the tools that change the work, not just the picture.
Field notes by Vista Studios. This essay reports the argument of Architect Magazine's 2026 archviz-workflow piece and characterizes Autodesk Forma, Finch, and TestFit from their publicly described roles. Tool capabilities are summarized at the vendor's stated level, not benchmarked here. No affiliate relationship with Autodesk, Finch, or TestFit.