The question under the question
Every architect I speak to is asking some version of the same question, and it is the wrong one. The question they ask is how AI fits into the workflow. Which renderer, which plugin, which point in the process, whether the intern still traces the plan. This is a real question and it has real answers, and all of those answers have a shelf life of about eighteen months.
The question underneath it is the one worth asking. If you are thirty-two and you expect to practise for another thirty years, what are you actually building that survives? Upskilling is a short-horizon answer. Learn the tools, prompt better, run the office leaner. Useful, and entirely insufficient, because the tools you learn are the ones being obsoleted fastest. The long-horizon answer has to come from somewhere else: from an honest reading of what machines are becoming capable of, and from the one industry that has already run this experiment to completion.
That industry is software. The parallel is not decorative. It is the closest thing we have to a controlled trial of what happens to a creative profession when the cost of production collapses to nearly zero, and it finished running about a year ago.
What the machines are learning
The interesting development in AI over the last two years is not that models write better prose. It is that they have started to hold space.
Generative video learned to produce plausible motion without any internal notion of where things are. World models are the correction. They maintain state across a viewpoint change, they keep an object in the place you left it, and increasingly they emit structure rather than pixels. World Labs made this argument well in their piece on 3D as code: when a model produces a structured 3D representation instead of a flat frame, that representation can be opened, edited, simulated, and handed to another system. It behaves like source code. It participates in a pipeline.
I have written about the consequence of this elsewhere, in the argument that a world model now has to beat an agent driving Blender. The point there was economic. Editable 3D is getting cheap enough that the benchmark for generated worlds is no longer photorealism, it is whether the output is usable downstream. That benchmark is the whole game. A beautiful frame is a dead end. A structured scene is an input.
Set this next to what is happening in robotics, where humanoid platforms are being trained to act in real interiors and the bottleneck has become spatial understanding rather than actuation. Two lines converge. Machines that can imagine space and machines that must operate in it are pushing towards the same requirement: a representation of the physical world that is dense, editable, and semantically legible. Once that representation exists, the distance between imagining a building and specifying one gets very short.
The near-term framing everyone uses is copilot. AI assists, the human decides. That framing held in software for about two years before it broke. It will break here too, and it will break in the same direction: the machine in the seat, the human nudging, and the nudge being the entire professional contribution.
The rehearsal already happened
For thirty years the internet was written by hand. Every layout, every component, every endpoint, typed by someone who had learned to type it.
That is over, and the numbers are blunt about it. The 2026 Thales and Imperva Bad Bot Report puts automated traffic at more than 53% of all web traffic in 20251, up from 51% the year before, the second consecutive year in which machines outnumbered people. Cloudflare's own radar puts the figure closer to 35%2, which is a useful reminder that these measurements depend enormously on whose estate is being measured. Take the lower number. It does not matter. Traffic composition is the least interesting part of the story.
The interesting part is authorship. Production code is now substantially machine-written and the profession has stopped pretending otherwise. Interface design has gone the same way faster than anyone expected, because interface design was always the most pattern-dense discipline in software. The vocabulary shifted from writing code to specifying it: spec to prod, intent to application. School-age children are shipping working AI applications through programmes like MIT App Inventor's global appathon, not as novelty but as competent entries judged against real problems. The gate that used to separate a person with an idea from a person who could ship it has effectively dropped.
Watch what this did to the incumbents. Every seat-licensed software company on earth is currently being asked the same question by its board, which is what happens to per-user pricing when the user is an agent and the software can write itself. SAP, Salesforce, the whole enterprise estate. Nobody has a comfortable answer. The end state people are quietly modelling is one where a program is imagined, built, market-tested, and iterated with no human in the production loop at all, and where the residual human act is deciding what should exist.
The built environment is upstream of none of this. It is simply later.
Aesthetics converged
Aesthetics converged. A handful of component libraries got very good and very cheap to reproduce, and now a large fraction of new software looks like the same product. Identical spacing, identical radii, identical restrained neutrals. When I direct an interface today I do not describe visual qualities. I name a library, name a styling convention, drop two reference images, and the assimilation of those constraints produces the look. The specification is a set of pointers, not a description.
This is the most important mechanic here, so it is worth stating plainly. Authorship did not disappear when production got automated. It moved upstream, into the libraries. The people who wrote the component systems that everyone now assembles from have more aesthetic influence over contemporary software than any individual designer working today. They set defaults, and defaults became the world.
If you want to know where authorship goes in architecture, that is the answer, and it is not a demotion. It is a considerable amount of power concentrated in very few hands.
Buildings are not websites
Here is the objection, and it is a good one, so let me make it properly before answering it. Software automated fast because software is forgiving in ways the physical world is not. The marginal cost of another iteration is zero. The feedback loop is instant. Nothing has to stand up under gravity. Nobody dies when the layout is wrong. There is no permitting authority, no eighteen-month construction programme, no supply chain that has to physically deliver the specified thing to a specific piece of ground, no material that behaves differently in Chennai than in Chandigarh. When a website fails you roll back. When a building fails you have a building that failed.
Every one of those is true. And every one of them is an argument about evaluation, not about generation.
This is the pivot. Generation was never the hard part in software either. The reason coding agents work is that software carries its own evaluator: it compiles or it does not, the tests pass or they do not, the deployment holds or it falls over. Cheap, fast, automatic verification is what allowed generation to be handed over. The generative model got useful precisely because something else could tell it, at essentially no cost, whether the output was any good.
Architecture has no such evaluator, and that is the actual bottleneck. Not imagination. Not drawing. The absence of a cheap way to ask whether a proposed piece of space is good, and to get an answer with the reliability of a compiler. We currently answer that question with the accumulated intuition of an experienced practitioner, applied slowly, at high cost, to one project at a time, unverifiably.
Which means the direction of travel is the reverse of what most people assume. The industry keeps trying to build generative design tools that produce more options faster, which is the least valuable thing anyone could build right now. The unlock is evaluation. Build something that can assess a proposal against daylight, movement, thermal behaviour, code compliance, cost, buildability, and the far messier register of whether people will want to be in the room, and generation follows almost as a by-product. Pressure applied to evaluation is what produces good options. This is why the physical constraints, which look like the reason architecture cannot be automated, are in fact the substrate on which its automation will be built.
What the transaction looks like
Ten years out, imagine someone who owns a plot and has never spoken to an architect. They have a survey of the site, which by then is a captured spatial record rather than a drawing. They have a brief in their own words, which is mostly about how they want to live. They have a folder of images that they cannot articulate but know they respond to. They have a budget, a climate, a set of local regulations, and the availability of whatever the local supply chain can actually deliver.
They will get back a proposal that is resolved. Not a moodboard, not a plan that a professional then has to make real, but a specification detailed enough to build from, tested against the constraints, priced against the market, and legible to the people who will construct it.
This is exactly the shape of the interaction I have with an interface model today. Reference images, a stylistic pointer, a constraint set, and an executed answer. There is no reason the shape changes when the output is a house instead of a screen, once the evaluator exists.
If you are an architect, the instinct is to explain why this is impossible. Resist it for a minute and ask the more useful question, which is what you are doing in that transaction, because you are still in it.
Where the architect actually goes
Back to the libraries. Somebody has to write what good looks like in a form a machine can assemble from. In software that meant component systems: a button, a card, a modal, each carrying its own constraints and its own interfaces and its own opinions about spacing. In the built world it means something similar and much richer, because the components carry material, structure, climate behaviour, cost, and cultural meaning along with their geometry.
An architect who writes the spatial vocabulary that ten thousand houses are assembled from has more consequence than one who draws forty houses well.
That authorship is not a diminished version of practice. It is practice at a different altitude. The unit of work changes from the project to the system, and the reward changes from the fee to the adoption.
Alongside it sits a less glamorous and equally decisive job, which is digitisation. Every material, every component, every assembly that is not represented in machine-legible form is invisible to this process and will be substituted out of it. If the kota stone, the local brick, the terrazzo mix, the joinery detail that a particular workshop in a particular town has perfected are not described in a form a model can reason over, they will not appear in what gets built. The catalogue is the culture. Whoever bothers to encode a tradition is the one who keeps it in circulation.
This is the sharpest reason for practitioners to move early rather than wait to be disrupted. The vocabulary is being written now, and it is being written mostly by people who have never detailed a building.
What does not transfer
The parallel has a limit and it is worth naming precisely. Somebody has to be responsible when the slab cracks. That responsibility is legal, insurable, and personal, and no amount of capability shifts it onto a model. Architecture is not only a design profession, it is a liability structure and an accountability mechanism, and that part does not automate because society will not permit it to. The signature on the drawing is a promise made by a person who can be sued.
That residue is small and it is extremely load-bearing. It is also, I suspect, where the economics of the practice end up: not paid for the drawing, which will cost nothing, but paid for the judgement and the assumption of risk that the drawing is right. Which is a very different firm to the one that exists today, structured differently, staffed differently, billing on something other than a percentage of construction cost. That is its own argument and I will make it separately.
The tools are built for the wrong species
Everything an architect uses today assumes a human operator. The interface, the file format, the workflow, the entire conceptual model of drawing as an act of hand and eye. Even the modern tools that call themselves intelligent are assistive layers over software that was designed for a person clicking.
The next generation of design tools will be built for machines to use, with people directing. That is a different artefact entirely. It needs formats that carry constraints and not just geometry. It needs data about how spaces actually perform and how people actually behave in them. It needs material information from the people who make materials. It needs regulatory logic in machine-readable form. None of this can be produced by a software company alone, because none of it is a software problem. It requires the participation of practitioners, fabricators, suppliers, and regulators, which is to say it requires something with the shape of a commons.
And this is where the current industry structure fails badly. The obvious future is that one incumbent builds this, closes it, and sells it back to the profession as another seat licence. Architects have lived inside that arrangement for three decades and know exactly how it feels. It would also be technically worse, because a closed vocabulary written by one vendor will be thin, generic, and biased towards whatever is easiest to model.
The alternative is the one that actually happened on the internet, which is open. The internet became what it is because the substrate was not owned. Anyone could publish, anyone could fork, anyone could contribute a library, and the standards were argued over in public rather than shipped by a vendor. That is not a moral preference, it is a functional one. Open substrates accumulate contributions and closed ones do not.
For that to be more than a slogan here, three things have to exist, and they map almost exactly onto what software needed.
- A component format. A way to describe a piece of built space that carries its identity, its constraints, its interfaces, and its performance, and that can be composed with other pieces without a human resolving every collision. The package, in other words.
- A public registry. Somewhere these components live, are versioned, are attributed, are searchable, and can be pulled by anyone building anything. The registry is what turned open source from a philosophy into an economy.
- An evaluation harness. The compiler equivalent. A way to submit a proposal and get back a verdict against structure, climate, code, cost, and use, cheaply enough to run a thousand times. Without this the first two are a filing system.
None of these exist. All of them are being gestured at by people building adjacent things.
What we are doing about it
We have spent the last while working on exactly this, and we are going to start putting it out in public rather than developing it quietly.
There is a paradigm here that we think is the right one, built around a small number of primitives: spatial units that carry their own contracts, the logic that governs how those units compose, and simulation as the thing that drives the whole process rather than merely checking it afterwards. That last inversion is the part we are most confident about, and it follows directly from the argument above. Evaluation is the engine. Generation is what falls out of it.
We are not going to lay the whole framework out here. What we want first is the argument, and the disagreement, and the people who have been thinking about this from their own direction and have reached different conclusions. If you are practising, fabricating, supplying, regulating, or building the tools, we would like to hear where you think this is wrong.
The vocabulary of the next built world is being written right now. There is still time to decide who writes it.
Footnotes
-
2026 Bad Bot Report, Imperva & Thales, 2026. ↩
-
Cloudflare Radar, Cloudflare, 2026. ↩