You know that feeling. The cursor hovers over the terminal. Your finger pauses above the Enter key. For half a second — maybe less — you weigh everything. The commit message. The branch. The changes you think you made versus the changes you actually made. Then you type git push, hit Enter, and feel it: a tiny, electric jolt of ownership.
That jolt is about to disappear forever.
Not because git is dying. Because the hand on the keyboard is no longer yours.
Git push was never a technical operation. It was a covenant — the moment a developer said, ‘This is mine, and I stand by it.’
Autonomous coding agents don’t make covenants. They make API calls. They don’t hover. They don’t hesitate. They don’t feel the weight of a bad commit at 2 AM because they don’t feel anything at all. And that should unsettle you more than any hallucination or security vulnerability ever could.
Let’s be honest about what git push actually was for the last two decades. It was the last human checkpoint in a pipeline that has been systematically removing humans from every other stage. Code review? Automated. Testing? Automated. Deployment? Automated. But the push — the push was still yours. It was the final act of volition, the moment where a developer transformed from a passive observer of code into its accountable author. It was the signature on the painting.
Now agents are picking up the brush.
I’ve watched this shift happen in real time. A developer describes a feature in plain English. An agent writes the code, stages the files, crafts the commit message, and pushes — all in the span of a breath. The human never touches the keyboard. Never reads the diff. Never feels that half-second of dread that makes you double-check everything one last time.
And here’s the thing nobody in the AI tooling space wants to admit: that half-second of dread was doing more work than any linter, any CI pipeline, any test suite ever could. It was the psychological anchor. It was the friction that made care possible.
Remove the friction of commitment and you don’t just speed up development — you amputate the developer’s sense of responsibility for what they ship.
The comments on this shift reveal the real anxiety. One developer said the biggest emotion they ever felt with git was fear. Another said agents seem unnecessary. What they’re both expressing, in different ways, is a desperate clinging to the ritual — because the ritual is where their authority lived. Take away the push, and you take away the moment where the developer existed as something more than a spectator in their own codebase.
Some will say git itself is the wrong tool for agents. That we need a fundamentally new version control system built for autonomous workflows. Maybe. But that misses the point entirely. The problem isn’t the tool. The problem is that we’re replacing a human moment of accountability with a machine action that carries no weight, no memory, no consequence — and calling it progress.
A commit made without hesitation isn’t a commitment. It’s just a transaction. And transactions don’t build engineers. They build operators.
This isn’t nostalgia. I’m not mourning a command. I’m mourning what the command represented: the idea that a developer’s name on a commit meant something, because they chose to put it there, deliberately, with full awareness of what they were sending into the world.
When an agent pushes code on your behalf, whose name is on it? Yours? The agent’s? The framework’s? The answer, right now, is uncomfortably: nobody’s. And code with no owner is code with no accountability. Code with no accountability is code that rots faster, breaks harder, and hurts more people when it fails.
The industry will tell you this is efficiency. The industry is wrong. This is surrender dressed up as speed.
Every developer who has ever felt that jolt before pressing Enter knows what’s being lost. It’s not the keystrokes. It’s the knowledge that you — a human being with judgment and fear and care — made a decision that would persist in a history someone else would read. That history was a story of human choices. It’s about to become a log of machine transactions.
The day git push stops meaning something to a human is the day development stops being a craft and becomes mere infrastructure. And infrastructure doesn’t have a conscience.
So no, this isn’t an elegy for a command. It’s a warning about what happens when we hand over the one ritual that made us accountable — and don’t even notice it’s gone.
FAQ
Q: Isn't this just nostalgia for an outdated workflow?
A: No. The hesitation before git push wasn't inefficiency — it was accountability made physical. When you remove the human moment of commitment, you don't just speed things up. You remove the psychological weight that made developers care about what they shipped. Speed without ownership is how bad code multiplies.
Q: What should developers actually do about this?
A: Stop letting agents push autonomously. Use them to write, to draft, to suggest — but keep the push as a deliberate human act. If you let the agent commit and push in one breath, you've surrendered the one checkpoint that made you the author, not just the operator.
Q: Isn't git itself the problem? Don't we need new version control for agents?
A: Maybe we do. But new tooling won't fix the real issue: removing human accountability from the commit moment. You can build the most sophisticated agent-native VCS in the world, and if no human ever pauses to say 'this is mine,' the code will still rot from lack of ownership. The tool isn't the problem. The absence of the ritual is.