I expected great things as I stood staring at my coffee machine.

Coffee before a long Zoom session is a ritual I've repeated for years. It marks the transition. The emails have been answered. Slack has gone quiet. Whatever is about to happen deserves my full attention.

The few minutes before a demo are my favorite.

Nobody is presenting yet.

Engineers drift into the meeting one square at a time. Someone is still adjusting their camera. Someone else apologizes for their dog barking. There is always a joke about the weather. Someone mentions they only slept four hours. Another engineer laughs and says that's a good night.

The tension hasn't arrived yet.

For a few minutes, everyone believes the software is going to work.

There's an optimism in those moments that I still enjoy, even after all these years. We congratulate ourselves before we've earned it. We celebrate what we're certain we're about to see. We drink our own Kool-Aid because, for a little while, believing is more fun than knowing.

Then the screen share starts.

The login page filled my monitor.

It was beautiful.

The typography was clean. The spacing felt intentional. Validation messages appeared exactly when they should. Every pixel looked like someone cared.

This was going to be good.

I moved my mouse over the Login button.

Clicked.

Nothing.

No loading spinner.

No request.

No authentication.

Just a button sitting exactly where it was designed to sit.

I clicked it again.

Silence.

I looked at the engineer.

He was still smiling.

"Nobody asked me to make the button actually log anyone in."

Nobody laughed.

Not because it wasn't funny.

Because everyone in that meeting realized we'd just learned something far more important than whether the software worked.

We had learned how the engineer thought.

He wasn't lazy.

He wasn't stupid.

He had done exactly what was written on the ticket.

The problem was that he believed his responsibility ended where the ticket ended.

I've thought about that meeting more than I should.

Not because of the button.

Because I've seen that same engineer dozens of times.

Different company.

Different face.

Same outcome.

Today, the tools are different.

Every engineer wants Docker.

Terraform.

Cursor.

Claude.

ChatGPT.

The next AI agent promising to replace the last AI agent.

I'm not against any of them.

I use them every day.

They're remarkable.

They're also irrelevant.

Because tools have never made anyone a professional.

A torque wrench doesn't make someone a mechanic.

A scalpel doesn't make someone a surgeon.

And Claude doesn't make someone an engineer.

Earlier this year, an engineer asked me to review more than five thousand lines of code.

He'd generated it in a single day.

Five thousand lines.

I made it a few functions before I stopped reading the code.

I started reading the engineer instead.

The variable names changed without reason.

The same logic appeared three different ways.

One function contradicted another.

Error handling existed in one place and disappeared in the next.

The code wasn't the problem.

The engineer had never read it.

Not carefully.

Maybe not at all.

He prompted.

The model answered.

He copied.

He pasted.

Then he asked me to verify what he had never bothered to understand.

Think about what happened there.

A company paid an engineer to produce software.

Instead, they received a prompt.

Then they paid someone else to determine whether the prompt had accidentally become a product.

We like to call that leverage.

Productivity.

Acceleration.

Sometimes it's something else.

Sometimes it's gambling.

You're betting your customer's business on software you never took ownership of.

You're collecting a paycheck for judgment you never exercised.

Call it efficiency if it helps you sleep.

I don't.

I call it stealing.

AI didn't create this behavior.

It exposed it.

Poor engineers used to hide behind complexity.

Now they hide behind prompts.

The workflow changed.

The mindset didn't.

Prompt.

Paste.

Push.

Production has become the first reviewer.

Customers have become unpaid testers.

Outages become learning opportunities.

The postmortem becomes the code review that should have happened before deployment.

A professional uses AI differently.

A professional knows exactly what the tool is.

It's a remarkably capable assistant.

It drafts.

It summarizes.

It explains.

It accelerates.

It does not accept responsibility.

It does not wake up at two in the morning because production is down.

It doesn't have to explain to a customer why their business stopped working.

You do.

Professionals trust tools.

Then they verify them.

They ask another question.

They read every important line.

They test the assumptions.

They understand that AI was built by imperfect humans and trained on imperfect software.

If you've worked in this industry long enough, you know something uncomfortable.

The final bug always belongs to the last person who said, "Looks good. Ship it."

I've worked with engineers making eighty thousand dollars a year who I'd trust during a production outage without hesitation.

I've worked with engineers making four times that who couldn't explain code they committed the day before.

The difference wasn't intelligence.

It wasn't experience.

It wasn't the tools.

It was pride.

Pride in the craft.

Pride in the outcome.

Pride in knowing that somewhere, someone you've never met is trusting software you'll never see them use.

Those are the engineers I want.

The ones who ask why before they ask how.

The ones who understand the business before they argue about the framework.

The ones who know customers don't care whether you used Docker, Terraform, Claude, Cursor, ChatGPT, or whatever launches next Tuesday.

Customers don't buy tools.

They buy confidence.

They buy reliability.

They buy software that quietly does its job.

They assume that when they click the Login button, someone cared enough to make sure it actually logs them in.

At this point in my career, I don't care what tools you use.

Use all of them.

I do.

Just don't outsource your judgment.

Don't outsource your curiosity.

Don't outsource your responsibility.

Looking back, the login button wasn't the problem.

If we'd caught it in QA, we'd have laughed, fixed it, and forgotten about it.

The problem was that someone believed shipping the ticket mattered more than shipping the outcome.

That belief doesn't stay inside engineering.

It spreads.

Sales ships presentations nobody rehearsed.

Marketing publishes copy nobody fact-checked.

Finance builds forecasts nobody questioned.

Companies become whatever standards they tolerate.

//James Williams