Software engineers are all architects now

I was pulling all-nighters for a high-stakes demo, and the AI agents were incredible. Features that used to take a week were landing in an afternoon and it felt like a superpower.

Then I started testing.

Bugs everywhere. Caching errors. Thread-safety issues. Code that had worked fine for months, quietly broken by some subtle decision nobody made on purpose. Everything compiled. Everything ran. And then the gotcha arrived. It always arrived.

I was spending half my time debugging AI output, and the other half anxious about what I’d find next. And somewhere around two in the morning, I realized the feeling I had wasn’t excitement anymore. It was the feeling of pulling a slot machine lever. You type a prompt, the reels spin, and you get whatever you get. It looks right. It looks right every single time — until it doesn’t.

Here’s the thing: I never stopped using the agents. Nobody’s going backward. The speed is real, and it’s incredible, and anyone telling you to write it all by hand again is selling nostalgia. But I started asking a different question.

The job already changed. The tools didn’t.

We’ve been here before. We used to program computers with punch cards. Then assembly — push this register, jump here, add these numbers. Then Dennis Ritchie built C, and suddenly you weren’t thinking in instructions anymore, you were thinking in logic. Every one of those shifts felt impossible until it was obvious.

This is one of those shifts. The biggest one yet. The agents write the code now — thousands of lines while you get coffee — and the diff spews out the end like a receipt, and we all do the same thing with it. We don’t read it. Of course we don’t read it. Nobody reads a 2,000-line diff. We build it, we run it, we squint at it, and we say the five most dangerous words in software: “seems to work, ship it.”

And then it breaks the login page. Which you weren’t even touching. Because somewhere in those 2,000 lines it modified a core data model, and that looked innocuous, and now it’s 2am and your pager’s going off and the honest answer to “how does this work?” is the answer engineers everywhere are giving their directors every single day:

“I don’t know. The agent wrote it.”

Say that sentence out loud. That’s not an engineering culture. That’s building on quicksand.

The numbers back up the feeling: 84% of developers use AI coding tools now. 81% of enterprise teams have had AI-written code break in production. And 29% — twenty-nine percent — trust the AI-generated code they ship.* We adopted the tools and lost the trust. Speed without control isn’t engineering. It’s chaos with good marketing.

But here’s what nobody’s saying clearly: the engineer’s job didn’t disappear. It moved up a layer. We’re not coders anymore. We’re architects. We direct, we structure, we decide what must always be true and what must never happen. The agents are the workforce — a swarm of tireless, brilliant, slightly reckless builders. And every tool we use was designed for the old job. A file browser, a text editor, an agent bolted on the side. That’s a coder’s desk. Where are the architect’s tools?

Control isn’t a feature request. It’s an instinct.

The need to be in control of what you’re building might be one of the oldest human instincts there is. It’s the difference between making something and watching something get made. And I think that’s the real reason engineers feel so uneasy right now — it’s not the bugs, exactly. It’s that we sit down at our desks and we don’t feel like builders anymore. We feel like we’re yelling at an agent, and sometimes it yells back, and sometimes it’s even right, and none of it feels like the job we loved.

Engineers should sit down in the morning and feel what we’ve always felt: I build things. I create. I know how my system works, and I can prove it. That pride isn’t nostalgia — it’s the thing that makes the whole profession function, because at the end of every diff there is still a human being who is responsible. Andrej Karpathy said it best: agentic engineering is about preserving the quality bar while going much faster. You’re still responsible.

So the answer isn’t slower AI, and it isn’t reading every diff, and it isn’t a folder of markdown files the agent treats as a polite suggestion. The answer is what it’s always been in engineering: see what was built. Understand what it does. Enforce what must never happen. Verify before you trust.

But it starts with the tools. It starts with putting the engineers back in control, at the top of the stack, proud of the thing they’re building.

We believe:

• Engineers are architects now. The tools should finally act like it.
• Trust is earned by verification, not vibes. If it isn’t proven, it doesn’t land.
• Control is the feature. Everything else is decoration.
• Speed without control is chaos. Speed with control is the whole promise of this era.

We’re building Panolayer for this.

*Sources: Stack Overflow Developer Survey 2025; CloudBees State of Code Abundance 2026.