For decades, software architecture carried a simple definition: it's the stuff that's hard to change. That framing—straight from Building Evolutionary Architectures—was honest because it acknowledged what actually made a decision 'architectural': not its conceptual weight, but the wall-clock time required to reverse it. Coordination costs, handoff friction, cognitive load. Software architecture was always fundamentally a labor problem dressed up as a design problem. Until now.

The Code-Level Collapse

AI has collapsed that equation. Things that used to take months now take days—sometimes hours. Cloudflare's team reimplemented 94% of the Next.js API surface in under a week for roughly $1,100 in API costs. Christopher Chedeau ported 100,000 lines of TypeScript to Rust in a month. The author himself pointed Claude Code at his startup's NoSQL data layer and ported it to a conventional RDBMS in hours—work that 'might never have been accomplished before the heat-death of the universe.' These aren't edge cases anymore; they're becoming table stakes.

What's Actually Still Architectural

The author's six-category framework reveals three distinct movements. Decisions got demoted (local code structure, scalability and deployment posture) because AI collapsed their reversal cost from quarters to hours. They stayed put (data architecture, trust and service boundaries) because the hard part was never the code—data has gravity, accumulating mass over time in ways no LLM can enumerate; security breaches are effectively irreversible. And two concerns got elevated: observability and behavioral verification (because AI-generated code volume is exploding while human comprehension collapses), plus business strategy alignment (because architects finally have headspace to engage with it).

The Verification Bottleneck

You'll hear that AI makes code quality more important, not less—and technically that's true. Addy Osmani reports AI-generated code has 75% more logic errors and 2.74x more XSS vulnerabilities than human-written code. But here's what the skeptics miss: generation is no longer the bottleneck. Verification is. The discipline hasn't disappeared; its object has shifted from internal elegance to behavioral correctness and business value. 'Making code cheap to generate doesn't make understanding cheap to skip,' as Osmani puts it—but you can build correctness-checking into the process itself using AI.

Don't Mistake Ceremony for Discipline

The Fowler/DORA argument that internal quality drives speed was always about behavioral outcomes, not aesthetic ones. Elite teams aren't fast despite being disciplined; they're fast because discipline serves their users. But teams confuse markers of quality with quality itself: ceremony versus actual fitness for purpose. When restructuring was expensive, investing in elegance looked like investing in correctness—hard to separate. Now that refactoring is cheap, the gap between them is visible. Companies shipping rough software and winning markets understood this all along; technical excellence is neither necessary nor sufficient for market success.

The Elevation Pattern

Database migrations pushed schema work into general engineering roles; CI/CD did the same for deployment; AI is now absorbing most code-level decisions. Each time, judgment trapped behind mechanical cost got absorbed into the general role, and specialists had to find something more interesting to do. That process has reached architects. 'A decade ago, an architect could nod at business strategy and then go back to ports-and-adapters,' the author observes. 'There is much less room for that now.'

Key Takeaways

  • Code structure decisions (modules, frameworks, persistence) are no longer architectural—they're routine engineering
  • Data ownership, consistency models, schema evolution, trust boundaries, and service contracts remain genuinely hard to reverse
  • Observability and behavioral verification just became the most important architectural concerns you have
  • The bottleneck shifted from code generation to verification—build your harnesses first

The Bottom Line

The architect's job just got harder in the ways that matter and trivial in the ways that used to feel important. Stop debating framework choices; start owning service boundaries, trust contracts, and what your system actually does versus what users need it to do. That's where competitive advantage lives now—and it's the only territory that's still genuinely expensive to change.