The Checkpoint Is the Job

I refuse auto-commits. I refuse auto-changelogs. I refuse to let an agent push code without me having read every line.

That sounds inefficient. It sounds like I don't understand what the tools are capable of. It sounds like friction.

It IS friction. And the friction is intentional.

"Human-in-the-loop" Has Become a Checkbox

The industry has a phrase: human-in-the-loop. It sounds good in presentations. It sounds responsible. It implies there's a human somewhere in the process who signs off.

But look closer. Look at what it actually means in practice among the people who use the phrase.

It means a human has the opportunity to react. Not that they do. It means there's a step in the workflow where someone COULD review. Not that the review happens. It has become an organizational checkbox — "we have human-in-the-loop" — that shields against accountability questions without actually protecting against mistakes.

What I do is something different. What I do is make the checkpoint the work itself.

What I Actually Do at Every Commit

Every day I read every diff. Line by line. I ask myself: do I understand this change? Is it necessary? Is it correct? Does it do what I asked for — or did the AI do something extra I never requested?

Then I update the changelog manually. Not because it takes a long time. But because the moment of putting into words what changed forces me to understand what changed.

Automation removes steps. Deliberate friction makes every step count.

"The order is non-negotiable."

An auto-generated changelog is a summary of something no one has reviewed. It looks professional. It is meaningless. The changelog should be updated intentionally, never automated. The moment you automate the documentation of what you did is the moment you stop understanding what you did.

Why It Looks Like Inefficiency

I understand the objection. Tools that auto-commit, auto-document, auto-push save time. That's true. And if the metric is "number of commits per day" or "speed from idea to deploy," my process looks like a bottleneck.

But the right metric isn't speed per transaction. The right metric is speed per CORRECT transaction.

How many auto-commits need to be reverted? How many auto-generated changelogs say nothing about why a change was made? How much time goes into debugging things that never should have been pushed?

Deliberate friction is slower per step. But every step holds. And the sum of steps that hold is faster than the sum of steps that need to be redone.

Every Commit Is a Promise

What happens when I hit "commit" is not a technical act. It's a promise. I'm saying: I have read this. I understand this. I stand behind this.

Remove that moment and you remove the promise.

Automation doesn't replace the checkpoint — it eliminates it. And that checkpoint is not a necessary evil in the process. It IS the process. It's the moment where professional responsibility manifests in action.

This isn't about being afraid of tools. It's about refusing to give away the one thing that makes my name on the code mean something: that I actually decided it should be there.

Daily Practice

At 8 o'clock the day begins. AI generates, suggests, structures. I review. Every change, every file, every line. Then I decide what lives and what dies.

It takes longer. It costs more energy. But every line that survives that process is a line I can answer for. And being able to answer for your work — that's not inefficiency.

That's professionalism.

The checkpoint is not an obstacle on the road to delivery. The checkpoint is the job.