Product
Last month I hit a wall refactoring the backend. I kept switching models, expecting one to magically solve it.
Then I realized: I wasn't treating them as collaborators with different strengths. I was looking for a silver bullet.
The Strongest Model Doesn't Always Win
I've worked with Sonnet 4.5, Opus 4.5, and Codex GPT-5.3 Extreme High. On paper, you'd think the most advanced one wins.
In practice, that's not how it works.
Sonnet crushes backend debugging and refactoring. Its context handling is so strong it doesn't fall into patch-upon-patch memory traps.
Opus sometimes has brilliant moments. It draws on knowledge Sonnet doesn't have and breaks through bottlenecks I couldn't solve alone.
But most of the time, I'm not facing twisty puzzles that need that extra spark. I'm fixing routing logic, cleaning up state management, or ironing out edge cases.
Good Habits Beat Extra Firepower
If I map out the technical landscape before I start—common architectures, model tradeoffs, adjustable parameters—I don't need Opus's unique edge as often.
It's like working with people. More credentials doesn't always mean better output. Sometimes I need someone with strong context retention and domain insight who can grind through real problems—that's Sonnet.
Opus feels more fragile. It shines when the problem is just right, but I can't rely on it for day-to-day sprints.
Codex Surprised Me
Codex GPT-5.3 is solid in ways I didn't expect.
First: it doesn't over-promise. If something's uncertain, it says so.
Second: higher completion rate. When my instructions have room for interpretation, it handles ambiguity well or asks for clarification instead of guessing wrong.
Fun fact: when prototyping web interfaces, some models produce output that immediately signals "this was AI-generated"—the stylistic fingerprint is too obvious. Codex writes code that feels more neutral.
Third: better collaboration logic. Codex clearly trained on more interaction feedback. It understands that agents shouldn't fight each other. I've noticed Anthropic's models, when they overlap in task scope, keep editing each other's work endlessly. Codex knows when to stop.
How I Use Each Model Now
Sonnet 4.5 is my go-to for debugging. Geeky, relentless, fires through problems like a committed engineer.
Codex feels like an earnest engineer who really wants to contribute. Grounded answers, never rolls back arbitrarily, sometimes gives genuinely insightful suggestions.
Opus is particular. It makes decisions on its own, and when things break, it rolls back instead of pushing through. Tasks don't finish efficiently even when it ends with "all good."
Working with AI Mirrors Working with Myself
Here's what surprised me most: collaborating with coding agents became a mirror for my own thinking process.
When things feel inefficient, it's usually not the model's fault. It's amplifying gaps in my own planning:
- Did I map out the workflow in advance?
- Am I overcomplicating the problem?
- Have I clarified the ultimate goal?
The process reminds me of stochastic gradient descent. Good optimization doesn't converge instantly from the first step. It uses randomness and proper step sizes to reach near-optimal solutions from different starting points, avoiding local minima.
That's what working with AI feels like when I do it right. It surfaces where my thinking was unclear, breaks illusions I held onto—like blindly trusting the biggest model the same way people trust credentials or titles.
Nothing is "always best." It's about fit. Like playing cards: you don't need all kings, you need to position the right cards in the right places.
When you're clear, execution gets easier. The interesting part is realizing mid-work that you weren't clear to begin with.
At first it's just an idea. But building sharpens it. The process keeps asking: "Is this really it?"
The further you go, the work itself tells you if it makes sense. After doing this enough, I've stopped caring much about external validation.
Eventually, you know.
Do you believe in it?