The Horseless Carriage Pattern: Why New Technologies Copy Old Forms First
Updated
Knowledge on this page was mainly distilled from the following articles: You're Not the User Anymore, Static UI Isn't Legacy. It's Institutional Memory You Can Click. (Free tool included), You're Building a Stone Cathedral Out of Concrete.
When a genuinely new material or technology arrives, the first generation of products built with it almost always copies the forms of whatever it replaced. Architects draped marble facades over reinforced concrete. Early cars were literally carriages with engines instead of horses. Television was filmed radio. Websites were digital brochures. Photography tried to look like painting.
The pattern eventually breaks when someone asks what the new material can do that nothing before it could. Le Corbusier stopped disguising concrete and proposed five principles that exploited its actual properties: open floor plans, curtain walls of glass, buildings lifted on slim columns. The resulting architecture could not have existed in stone.
AI and the Current Phase
AI is in its horseless carriage phase. Most AI products today take an existing software category and add a language model. The underlying form, whether a document editor, search engine, or analytics dashboard, remains unchanged. The properties native to AI, such as reasoning across massive contexts, generating variations at near-zero marginal cost, adapting in real time, and turning natural language into an interface, suggest entirely different product forms that have not yet been widely built.
Q&A
What is the horseless carriage pattern in technology?
It is the recurring phenomenon where a new technology is first used to replicate the forms of the technology it replaced. The name comes from the earliest automobiles, which were literally horse-drawn carriages with the horse removed and an engine attached. The pattern appears across nearly every major technological transition.
How long does the horseless carriage phase typically last?
For automobiles, roughly fifteen years elapsed from the mid-1880s to the early 1900s before the car became a form that could not have existed in a horse-drawn world. The duration varies by technology, but the transition from imitation to native form typically takes at least a decade.
What breaks the horseless carriage pattern?
Someone stops asking how the new material can do the old material's job and starts asking what the new material can do that nothing before it could. In architecture, this shift produced modernism. In AI, it means moving past "how can AI help me do what I already do" toward "what can I build now that was impossible before."
What is the 'truth to materials' principle and how does it apply to AI?
Truth to materials is an architectural principle holding that every material has a nature and the best work follows that nature rather than fighting it. Wood bends, glass transmits light, concrete flows into any shape. Applied to AI, the principle asks builders to design for what AI natively does well, such as adapting to context, pursuing goals autonomously, and generating variations, rather than forcing it into existing software paradigms.
Why are incumbents likely to stay in the horseless carriage phase longer?
Large companies have deep investments in existing product forms. Microsoft is structurally incentivized to bolt Copilot onto Office, and Google to layer AI onto Search. Incumbents are biased toward incremental improvement of existing forms. Native AI forms are more likely to come from small teams with nothing to protect and no quarterly earnings call constraining their answers.
Is keeping a traditional UI in an agent-era product just the horseless carriage pattern?
Not necessarily. The horseless carriage pattern applies when old forms are preserved out of habit rather than function. Static UI elements like navigation and dashboards serve a distinct purpose: they encode institutional knowledge and enable discoverability. Removing them does not create a native agent form; it creates a cold start problem where users cannot find capabilities they do not know to ask about.
What might the 'native form' of AI-era software look like?
It likely has no persistent user interface. Instead of screens and dashboards, the native form is ephemeral code and API endpoints created by agents for agents, used once, and discarded. The human-facing layer becomes a thin crust on top of a deep machine-to-machine stack. This mirrors how the automobile's native form (low-slung, purpose-built chassis) bore no resemblance to the carriage it replaced.
Are current AI coding tools still in the horseless carriage phase?
Partially. Tools like Claude Code and Codex already exhibit native-form behavior: agents write scripts, run them, learn from the output, and throw the scripts away. That intermediate code was never meant for human eyes. But the outer shell of these tools, the chat interface, the IDE integration, still copies the forms of traditional developer tooling. The transition is happening from the inside out.