← All writing

AI Can Write the Code. But Who's Doing the Engineering?

Share
LinkedInEmail

I use AI to build software. A lot. I'm not going to pretend I sit there writing every line from scratch anymore, because I don't.

And I don't think there's anything wrong with that.

But there's a difference between getting AI to produce code and knowing what you're actually building. That's the part of this conversation that keeps getting lost.

We're making it easier than ever to create software. At the same time, we're making it ridiculously difficult for experienced engineers to get hired to build it.

I keep coming back to those two things, because they don't make much sense together.

Getting something to work isn't the hard part anymore

You can describe an application, give an AI tool a few instructions, and watch it put something together. Sometimes it looks great. Sometimes it even works on the first try.

That's impressive. I use those tools myself.

But what happens after that?

What happens when the application has to handle real users, bad input, changing requirements, and integrations that don't behave the way the documentation says they should?

What happens when you need to make a change six months later and nobody can figure out why something was built the way it was?

AI can generate a lot of code very quickly. It can also take you from A to B by way of D, Y, and C. You get the result you asked for, but now you've got a bunch of extra complexity you didn't need.

If you don't know what you're looking at, you may not even notice.

That's where experience matters.

I use AI, but I still engineer the software

I've been doing this for more than twenty years. The way I work has changed, especially over the last couple of years, but the responsibility hasn't.

I might have AI generate an implementation. I'm still the one deciding whether the approach makes sense.

Does this belong in the client or on the server? Are we exposing something we shouldn't? Is the data being validated? What happens when the API fails? Can somebody else come into this codebase and understand it? Are we solving the actual problem, or just adding another layer to get around it?

Those aren't theoretical questions. They're the kinds of decisions you make when you've spent years building, fixing, and maintaining software.

And sometimes the right decision is to tell the AI to throw out what it just wrote and start over with a simpler approach.

I don't see that as a failure of the tool. It's part of using the tool correctly.

There's a difference between asking AI to build an application and guiding it through the engineering of one.

Someone who's new to development can absolutely build something useful with AI. I'm not taking that away from anybody. But getting a working screen isn't the same thing as knowing whether the system behind it is secure, maintainable, or ready for production.

The spaghetti-code problem hasn't disappeared

We've always had developers who could get something working without thinking far enough ahead. AI didn't invent that problem.

It just made it faster.

Now you can generate entire features before you've really decided how they should fit into the application. You can keep prompting around errors, layering one fix on top of another, until the thing runs.

And because it runs, you assume it's done.

That's how you end up with software that's difficult to maintain, full of duplicated logic, and held together by decisions nobody can explain.

I've seen enough of that kind of code over the years to know how expensive it becomes later.

This is why I care about architecture, security, testing, and keeping things understandable. Not because every project needs some elaborate enterprise architecture. Most don't. Sometimes the best engineering decision is to keep it simple.

But you have to know when simple is enough, when it isn't, and what you're trading away.

AI doesn't remove the need for those decisions. It makes them easier to skip.

Meanwhile, look at what it takes to get an engineering job

Here's the other side of this that bothers me.

We have tools making software development more accessible than ever. Yet if you're an experienced engineer trying to get hired, the process can feel like an obstacle course.

Applications. Screening systems. Assessments. Coding exercises. Multiple interviews. Sometimes an AI-driven interview before you've even had a conversation with a person.

You can get through all of that and still receive a rejection with no useful explanation.

That's the part I think needs to change. If we're hiring engineers to work on real software, the process should tell us something about how they approach real software.

Instead, too much of the process seems designed to measure how well someone navigates the hiring process itself.

I'm not saying technical interviews shouldn't exist. Of course companies need to know whether someone can do the job.

But are we actually testing engineering judgment? Or are we testing how well someone performs an exercise that may have very little to do with the work they'll be responsible for?

There's a difference.

What should we actually be evaluating?

If I were evaluating an engineer, I'd want to understand how they think when things aren't straightforward.

Give them an existing application with a real problem. Ask them what they'd inspect first. Let them explain what they'd change, what they'd leave alone, and why.

Ask how they'd verify the fix. Ask what could break. Ask what happens when requirements change.

And yes, let them use the tools they'd actually use on the job.

I care much more about whether someone can recognize a bad implementation than whether they can type out a familiar solution from memory while somebody watches.

That doesn't mean fundamentals are optional. Quite the opposite. Without them, you don't have a reliable way to evaluate what AI gives you.

The fundamentals are what let you use the newer tools without handing over your judgment.

The job is changing. The responsibility isn't.

I'm not against vibe coding. I do a version of it myself. I'm against the idea that generating code and engineering software are automatically the same thing.

They're not.

AI has changed how I get work done. It lets me move faster, explore approaches, and spend less time on repetitive implementation. That's valuable.

But I still have to understand the system. I still have to make the calls. And when something goes wrong, saying "the AI wrote it" isn't an answer.

The question isn't whether AI can write code. We already know it can.

The question is who's making sure the software is worth keeping after the code has been written.

Share
LinkedInEmail
← Back to the writing archive