I Think Software Engineers Are Slowly Becoming Architects

I’ve been thinking about this a lot recently. I don’t think software engineering is dying, and I don’t even really think coding is dying. But I do think the part of software engineering that we consider the “main job” is changing really, really fast.

If I look at how I build software now compared to even a year or two ago, I’m writing code completely differently. And weirdly enough, I’m probably building more software than I ever have.

Typing is the smaller part now

I use AI a lot. Like, a lot. Not in the “I occasionally ask ChatGPT how to center a div” way. I mean I’ll have agents working through parts of a codebase, generating implementations, debugging something, creating migrations, researching libraries, writing tests, going through logs, or helping me reason through an architecture.

Because of that, I've noticed that the actual act of physically typing code is becoming a smaller percentage of my job. Not zero. Smaller. A lot more of my time now goes to questions like:

• What should this system actually look like?
• Should this be a separate service?
• What happens when this job fails halfway through?
• Does this actually belong in the database?
• What data does this agent need access to?
• What should happen synchronously and what should go through a queue?
• If 1,000 people use this at the same time, what breaks first?

And probably the most important one:

Does the code the AI just generated actually make sense?

The architect and the bricks

That’s why I've started thinking that software engineers are slowly becoming more like architects. Not in the job-title sense. I mean literally architects.

If you’re building a house, the architect isn’t necessarily the person physically placing every brick. But that doesn’t mean the architect knows less about houses. It means they need to understand the entire system well enough to make decisions that affect everybody else building it: structure, constraints, materials, trade-offs, failure points, and how everything fits together.

Software is starting to feel increasingly similar. AI can build a wall. It can probably build the wall faster than me. The important question is becoming: should there even be a wall there?

Two bad extremes

I think that's where some of the conversation around AI and programming gets a little weird. People usually take one of two extremes. Either “AI is going to replace every programmer,” or “AI is useless, real engineers code everything themselves.”

I don’t really agree with either. AI is ridiculously useful, and pretending otherwise at this point just feels stubborn. But being able to generate code is very different from being able to engineer a system, and that difference becomes painfully obvious once a project gets past the demo stage.

You can prompt an AI into making an authentication flow. Cool. Now:

• What happens when refresh tokens expire?
• What happens when a user belongs to two organizations?
• What happens if two requests update the same resource?
• What happens when your background job executes twice?
• What happens when the API you depend on goes down?
• What happens when the model confidently gives your agent the wrong tool parameters?
• What happens when you actually have users?

Those are engineering problems, and they're not disappearing. If anything, I think they become more important when generating software gets cheaper, because we're going to build way more things, and a lot of them are going to be built very quickly. Somebody still needs to understand what the hell is actually going on.

My bottleneck isn't the function

I've experienced this in my own projects. The more AI I use, the more I've realized that my bottleneck isn't really “can I write this function?” Usually, yes. And if I don't want to, an agent probably can.

The bottleneck is deciding what the function should do in the first place and how it should fit into everything around it. That requires context, judgment and experience. And sometimes sitting there staring at the architecture thinking, “yeah… this feels wrong.” Which is a very difficult thing to put inside a prompt.

Why I still think learning to code matters

There’s another side to this. I still think learning to code matters, probably more than people think. If AI writes your code and you have absolutely no idea what it's doing, you're not really directing it. You're just accepting output. Those are two completely different things.

I want to be able to look at something an agent generated and know why I don't like it. Why that abstraction is unnecessary. Why that database query is going to become a problem. Why this should probably be event-driven. Why that service has way too much responsibility. Why the code technically works but is still a bad solution. You can only do that if you understand the fundamentals underneath the abstraction.

So when people ask, “Why learn programming if AI can program?”, I think that's almost the wrong question. Calculators didn't make understanding mathematics useless. Higher-level programming languages didn't make understanding computers useless. Cloud platforms didn't make understanding infrastructure useless. They changed where humans spend their effort.

I think AI is doing the same thing. The abstraction layer is moving up. And personally, I love that. I don't particularly care whether I typed every line of a product. I care that I understand it, that it works, that it solves the problem, that I can maintain it when things inevitably go wrong, and that I made good decisions while building it.

Where this lands

Maybe five years from now the average engineer will write dramatically less code manually. Maybe we'll have teams where one engineer coordinates five coding agents. Maybe “programming” starts feeling more like describing systems and reviewing execution than manually implementing every piece. I don't know exactly where it lands.

But I'm pretty convinced about one thing. The valuable skill isn't going to be typing code the fastest. It's going to be understanding software deeply enough to know what should be built, how it should be built, and whether what got built is actually good.

That's still engineering. We're just getting much better tools.