OpZero Blog · February 2026
You Stopped Reading the Diff Three Months Ago
A continuation of Git is Dead to Me. If you haven't read that yet, the short version: git, files, and folders are human serialization formats that we force AI agents to work within. The agent doesn't think in diffs. It thinks in behaviors, states, and dependencies — then writes files because that's what we expect.
This piece asks the next uncomfortable question: if the agent already stopped thinking in diffs, when did you?
A few months ago, I noticed something about my own workflow that I wasn't ready to say out loud.
I was using an AI coding assistant. It proposed a change — forty-something files, a couple hundred lines. The diff scrolled past. I skimmed the green. I checked that the tests passed. I approved it.
I did not read the diff.
Not really. Not the way I would have read a teammate's PR two years ago, tracing logic through conditionals, checking edge cases, asking "why did you do it this way." I scanned for shape. I looked for red flags. I pattern-matched on vibes.
And here's the thing I wasn't ready to admit: I'd been doing that for months. The last time I genuinely read a diff from my AI assistant — the way reading used to mean something — I can't tell you when that was.
If you're honest with yourself, neither can you.
The Ritual of Control
In Git is Dead to Me, I argued that git's primitives — line-based diffs, commit messages, branches, merge conflicts — are optimized for human developers coordinating with other human developers. AI agents don't think in these terms. They think in intent and state. Files are output, not thought.
But I stopped short of the harder question. It's not just that git is a bad interface for the agent. It's that the terminal itself has become a bad interface for us — and we're clinging to it anyway.
Think about what your AI-assisted workflow actually looks like right now. Stripped of narrative, it's this:
- You describe what you want in natural language.
- The agent works.
- Output scrolls past.
- You say "looks good" or "try again."
That's not engineering. That's approval. And there's nothing wrong with approval as a role — but let's call it what it is instead of pretending we're still doing the other thing.
The diff review, the terminal output, the test suite scroll — we've kept the ceremony. We've kept the artifacts of oversight. But the actual oversight? The part where a human brain traces logic and catches what the machine missed? That's been fading for a while.
We're watching the GPS and calling it driving.
Why Are We Splitting the Interface When Roles Are Collapsing?
Here's what makes this even stranger.
2026 is the year tech roles started visibly collapsing horizontally. The boundaries between developer, designer, PM, and analyst are blurring fast. AI-augmented individuals are operating across those lines. The differentiator isn't what tool you use — it's what judgment you bring.
At the same time, AI companies are fragmenting their products into specialized interfaces. Chat for conversation. Code for the terminal. Cowork for desktop automation. Specialized agents for specialized contexts.
Why?
The answer you'll hear is that each context has different affordances. Terminal gives you file system access. Chat gives you conversation. Desktop automation gives you screen context. These are real constraints.
But the answer underneath that answer is: we haven't solved context management at scale. A 200K token window still can't hold an enterprise codebase. So the terminal acts as external memory. The file system compensates for what the model can't hold in its head.
That's pragmatic. It's also temporary. And it's worth asking whether we're building product strategy around a limitation that has a shelf life.
The ideal state is obvious when you say it out loud: one conversational interface with environment-aware agency. You describe what you want. The agent decides whether to read your repo, spin up a preview, modify files, run tests, deploy, or just talk. It does that transparently, with checkpoints where they actually matter — not everywhere, just to make us feel better.
The fragmented tools collapse back into one thing. Which is exactly what you'd expect in a world where roles are collapsing into one thing too.
What the Enterprise Is Actually Thinking
This is the part that most developer tooling discourse ignores.
Every handoff between interfaces is friction. Chat to terminal, terminal to browser, output back to chat. For an individual developer, it's tolerable. For an enterprise evaluating how many people need to touch a workflow, every context switch is a cost center they intend to eliminate.
What enterprise leadership wants is not complicated: the thing gets done correctly, with fewer humans in the loop. Three specialized AI products means three things to procure, integrate, train on, and secure. That's the wrong direction for the buyer who's thinking about automation, not developer experience.
Developer tooling companies are optimizing for developer comfort. Enterprises are optimizing for throughput. These goals are diverging, and when they diverge fully, enterprises won't choose developer comfort.
The uncomfortable question for developers: if your role in the workflow is already "describe intent, approve output" — and the enterprise would prefer to skip the approval step — what exactly are you defending?
The Honest Gradient
I don't think human oversight is worthless. Not yet. Models still hallucinate. They still make choices that are locally correct but architecturally wrong. They miss business context that lives in someone's head and nowhere else. The approval checkpoint catches enough real problems, often enough, that removing it entirely would be premature.
But the trajectory is obvious. The checkpoint is already migrating:
Review every change → Review outcomes → Review exceptions.
That's the automation gradient. We're all on it. The only question is where you are on the curve and whether you're being honest about it.
I'm building OpZero from the assumption that we're closer to "review outcomes" than most people admit. The deployment model is: tell the agent what you want, it deploys, you review what shipped — not every line that got you there. That's not because oversight doesn't matter. It's because the kind of oversight most of us are actually performing has already shifted, and the tooling should reflect that honestly.
The Question I Don't Have an Answer To
Here's what I keep turning over:
If the diff review is already performative for most tasks — if we're pattern-matching on green text, not reading logic — then who is the terminal for? Is it serving the developer, or is it serving the developer's self-image as someone who's still in control?
And if it's the second thing — how long do we keep building products around that?
I don't have a clean answer. But I think the conversation matters, because the tools we build now will either accelerate the transition to what's coming or add a layer of comfortable friction that makes the inevitable adjustment harder when it arrives.
What's your honest read? When's the last time you actually read the diff?
Jeff Cameron is a Lead Software Engineer and the founder of OpZero.sh, an AI-native deployment platform. He writes about the things developers aren't saying out loud yet.
Previously: Git is Dead to Me: Why AI Agents Hate Your Codebase