Evan Schwartz is the Chief Operations Officer at AMCS Group.
When you’re building software and break something at the module level, the blast radius is small. A bug in a function? You fix the function. Maybe a couple of calls. No big deal.
But at the architectural level, when you break something, it breaks everywhere.
That’s what I tell my Clean Architecture students at Jacksonville University. They’re learning what used to take developers years to understand. The gap between design and implementation is disappearing, and soon it’ll be zero.
AI can instantly implement whatever you describe, so your architectural decisions carry real-time, system-wide consequences. There’s no safety net anymore.
One student wrote a simple prompt: “Analyze each returned record and get everything about it.” It worked fine with 10 records. But those records had sub-records. The LLM chased those, too. The sub-records pointed back to the parent records. And off it went in an infinite loop.
The problem wasn’t the code. It was the untethered language in the design layer. “Get everything about it.” It seems harmless until it ripples through a live system. That’s what I mean when I say architects still have to bleed, but not over lines of code.
When ‘Everything’ Breaks Everything
If you’re off by an inch at launch, you’ll miss Mars by millions of miles. Architectural decisions work the same way. A small imprecision in your design language cascades. The conjunction “or” when you meant “and.” A functional requirement that doesn’t properly scope its boundaries. These aren’t syntax errors that an IDE catches. These are logic errors that cascade through your entire system before you realize what happened.
In the old days, you could make small mistakes and catch them during development. Now, AI tools like n8n.io or Lovable can instantly turn a design into executable code. There’s no human in the middle translating diagrams or user stories. Your words are the code.
The language itself becomes your syntax. Loose language brings loose results, only faster. We now have to think in meaning instead of mechanics. You need precise logic and language. And when something goes awry, you treat the AI like a junior developer and ask: “Why did you do this?”
The New Face Of Technical Debt
When first starting to build with AI, students tend to overexplain, dumping every piece of context into every prompt. It works at first, but as projects grow, that approach collapses under its own weight.
This is AI’s version of technical debt; the context lives inside prompts, not in the architecture.
Traditional technical debt could be refactored one module at a time. But when your “architecture” lives in one-off prompts, there’s no incremental fix. You either rebuild everything or live with the mess.
Preventing it means bringing structure back to design. We teach students to layer context deliberately, using frameworks like Model Context Protocol (MCP) and Architecture-as-Code. Store your intent and rules in versioned repositories. Reference them instead of repeating them. It’s the same discipline as Clean Architecture, just moved up a layer from code to context.
Teaching The Next Generation To Bleed Differently
This is where it gets tricky.
Every industry is automating its “junior” tier. While that looks efficient, it creates a long-term problem. If no one gets to struggle through the hard parts, where will the next generation of architects come from?
We’re experimenting with that question right now at Jacksonville University. We have three kinds of students: one-third with no programming experience, one-third who’ve taken an intro course or two and one-third with serious coding backgrounds.
You might think the seasoned coders would dominate, but it’s actually that middle third who are thriving. They understand the concepts but aren’t stuck in syntax. They’re logical, creative and hungry to build. They’ve realized they don’t need to type 10,000 lines of code to understand abstraction; they just need to know how to guide an AI to build it for them.
These are the early signs of a new kind of engineer, one who’s part architect, part product owner and part conductor of intelligent systems.
Mentorship In The Age Of AI
In this world, debugging looks different. You’re not wading through lines of code; you’re asking the AI why it made a particular choice.
Mentorship becomes interpretive. Senior architects coach junior architects on how to coach the AI. They review reasoning traces instead of function calls. They ask questions like, “Why did this happen?” instead of, “What broke?”
In my classroom, we treat AI like a junior developer that is talented but literal. It doesn’t need you to code for it. It needs you to communicate with it. Precision replaces patience as the top developer virtue.
When students understand that, you can almost see the lightbulb flicker on. That’s the new kind of bleeding; learning how to express intent clearly enough that even an AI can’t misinterpret it.
The Rise Of The ‘Super Architect’
As companies automate their mid-tier workforce, they lose their training ground. If your only senior developer retires in five years and you’ve got no one ready to replace them, you’ve got a real problem.
That’s why I believe the next decade belongs to what I call Super Architects, the people who sit at the intersection of business, technology and AI. They’re not the old-school coders hiding behind a terminal. They’re charismatic, systems-thinking generalists who can translate human goals into machine logic.
They don’t need to know every programming language. They need to know how to orchestrate people, data and agents around a single vision.
The Human Edge
AI will eventually write AI. That’s inevitable. It’s already happening in chip design and machine learning.
But what it won’t have (at least not yet) is intent. That’s the last human domain.
The architect’s job has always been to bring vision and structure into harmony. That hasn’t changed, it’s just moved up a level. The new bleeding edge isn’t about syntax; it’s about meaning.
No, architects haven’t stopped bleeding. They just do it higher in the stack. And if we do it right, the next generation won’t bleed over code; they’ll bleed over imprecise thinking that cascades through entire systems before anyone notices.
Forbes Technology Council is an invitation-only community for world-class CIOs, CTOs and technology executives. Do I qualify?
