Knowing was never the job

An engineer gets a bug. What comes back to me is a wall of AI text. Nobody is going to read it. Nobody is going to understand it. And the first sentence is wrong.

Everything needed to get it right was in there somewhere. Nobody checked before hitting send.

So here's my question:

If you can't judge it, and I'm going to end up reading wrong AI slop anyway, why am I reading it from you? Why are you needed?

Typing code is dead

Let's stop pretending. Anyone can generate code now. Type what you want and a convincing app comes back. Login, database, API, tests. It runs. It demos. Your meth head cousin could do it, if he could sit still long enough to type the prompt.

That's fine. Typing was never the job. It just ate most of the day, so we confused the two.

The facts were never the job either. They only paid because they were hard to get. AI has the syntax, the flags, the framework internals and the security checklist. For everyone. Instantly. Not always right, but always there.

What's left is deciding whether any of it is right. Someone still has to say no.

The app works. That's the problem.

Ask AI for a REST API and you'll get one. It will have login. It may not check that the record you asked for belongs to you. Change the ID in the URL and you're reading someone else's invoices.

That's authentication without authorization. Authentication asks who you are. Authorization asks what you're allowed to touch. Not every vibe-coded app skips the second. But that's been the complaint about them from the start: they work, and they aren't secure.

And security is only one of the things that get missed:

• Every request hits the database, and nobody tested what happens under load.

• The API trusts the price the browser sends.

• The secret key ships in the JavaScript bundle.

Nobody checked, because everything worked.

Demos test the happy path. Attackers don't.

AI knows. You didn't ask.

Here's the part that should scare you:

AI already knows about most of the mistakes we're making.

Ask it to review its own code and it'll often find problems it never bothered to prevent.

You still need knowledge. You can't judge what you don't understand. But knowledge is something you can rent now, and AI will hand you most of what you need to check its own answer. What it can't do is own the consequences of getting it wrong. That part is yours.

A surgeon has to know anatomy. Nobody pays a surgeon for knowing anatomy. They pay for the decision to cut, where to cut, and when not to.

Knowledge is the tool. Judgment is the job. It always was. The wall of text I got for that bug had all the knowledge in the world and none of the judgment. That's why the first sentence was wrong and nobody caught it.

We shipped these bugs too

Before the old guard gets smug: we wrote these exact bugs by hand for decades. That's why the OWASP Top 10 exists.

Getting burned teaches you what can go wrong. The outage, the bad deploy, the postmortem with your name on it. That's knowledge, and it's worth having. But it doesn't stop you shipping the next one. Plenty of engineers have been burned and still hit merge without looking.

Judgment is what you do with it: assume you've missed something and check before it ships, every time, even when the demo works. AI knows most of the failure modes in the book, and it can be set up to check for them. It still can't own what ships.

From where I sit, AI has done one thing nobody expected:

It's exposed who was actually good at this job.

The engineers who were good before AI still question what comes back. The ones who just ship it anyway can't hide anymore.

That chasm has never been wider, and seniority isn't protecting anyone on the wrong side of it.

The difference is speed. A bad engineer used to ship bad code at the speed they could type it. Now they can ship it at the speed AI can generate it. The mistakes didn't change. The volume did.

Stop hiring for trivia

For years we hired for memory: name the status codes, explain the event loop, walk through the framework's lifecycle.

Reciting it never proved you knew what to do with it. And now AI can recite it too.

Here's the interview I'd run today. Hand someone a plan AI wrote. It looks clean. It has a hole in it. Let them use any tool they want. What do they ask? What do they check? Will they say no?

Be the one who looked

Back to that bug.

If your contribution is pasting what AI said, I can ask AI myself. It's faster, and it won't make me read a wall.

The surgeon you want isn't the one who memorized the textbook. It's the one who knew where to look when everyone else missed it.

That's the engineer I need. The one who changed the ID in the URL before an attacker did. The one who read past the first sentence. Then sent me one sentence I can trust, because they checked it.

That's what engineers still get paid for. Not the typing. Not the knowing. Being the one who looked.

Knowing was never the job. It only looked like it while knowing was rare.