How I use Cursor, Claude, and Codex together

Most developers I talk to use one AI tool for everything. I think that's a mistake. These tools have different shapes, and the workflow improves a lot once you stop treating them as interchangeable.

Here's the division of labor that works for me.

Cursor: where code gets written

Cursor is my editor, so it's where most code starts. The pattern that works: I scope the change myself first (which files, what the interface should look like, what must not break), then hand the agent a tight brief. The smaller the brief, the better the diff.

What I never do is accept a multi-file diff without reading it. AI-generated code fails in quiet ways: a plausible-looking error handler that swallows the error, a migration that works on empty tables only. Review like it came from a junior dev with infinite stamina and no fear of being wrong.

Claude: where thinking happens

Before code, there's architecture, and that's where I use Claude the most. Things like: should memory retrieval happen before or after the supervisor routes to a specialist agent? What's the failure mode if the vector store is stale? Claude is good at holding a whole system in its head and arguing about trade-offs.

Claude Code, in the terminal, handles the repo-wide work: multi-file refactors, dependency upgrades, "find every place we construct this client and add a timeout." Tasks where the editor-centric flow of Cursor is the wrong shape.

Codex: the second opinion

The most underrated workflow: give the same task to two agents and diff the approaches. When Codex and Claude disagree about an implementation, the disagreement is almost always pointing at something underspecified in my own thinking. That's cheap signal: two model runs to find the hole in a spec before it becomes a bug.

Where I still don't trust any of them

Three areas where I write or verify everything manually:

Eval logic. If the AI writes the evals that judge the AI system, you've built a closed loop. I write eval criteria by hand, always.

Security boundaries. Tool permissions, row-level access, anything in an agent's blast radius. Agents are enthusiastic about granting themselves capabilities.

Anything irreversible. Migrations, deletion flows, billing. The agent drafts, a human owns the merge.

The actual lesson

The tools change every few months; the principle doesn't. AI coding works when the human owns the specification and the verification, and the agent owns the typing in between. Every production incident I've seen from AI-assisted code traces back to a human skipping one of those two ends, never the middle.