The AI coding agent space has gone from "novelty" to "daily driver" fast. Three tools — Claude Code (Anthropic), Cursor (the IDE), and OpenAI Codex CLI — all claim to save you hours. But do they actually deliver when the task gets messy?
I ran the same non-trivial feature through all three: building a URL shortener service with a REST API, Redis caching, and Docker deployment. Same repo, same constraints, same evaluation criteria. Here's what happened.
Task: Create a Flask/FastAPI-based URL shortener with:
/shorten accepting JSON {url, custom_alias?}
/:alias redirecting with 301
Environment: Mac M2, 16GB RAM, latest versions of each tool as of this week.
Metrics I tracked:
Claude Code (Anthropic) won on code quality. The initial implementation was clean, type-hinted, and the Docker Compose file just worked. It asked clarifying questions when the prompt was ambiguous — which slowed it down by ~10 minutes but saved rework later.
@app.post("/shorten")
def shorten_url(request: ShortenRequest, db: Session = Depends(get_db)):
alias = request.custom_alias or generate_short_code()
if db.query(URLMapping).filter_by(alias=alias).first():
raise HTTPException(status_code=409, detail="Alias taken")
Cursor was fastest to first commit. Its inline acceptance model meant I could review line-by-line, which felt more controlled. But it hallucinated a Redis connection pool config that silently failed — I caught it only because I read the logs.
Codex CLI (OpenAI) was the cheapest per task (~$0.03 in API costs vs ~$0.12 for Claude). It produced working code but needed the most manual patching. The Dockerfile had a multi-stage build that broke on arm64 — classic architecture mismatch.
| Tool | Time to Working | Estimated Cost | Manual Fixes | Context Window |
|---|---|---|---|---|
| Claude Code | 42 min | ~$0.15 | 2 minor | ~180k tokens |
| Cursor | 28 min | ~$0.08 | 3 (including Redis bug) | ~128k tokens |
| Codex CLI | 35 min | ~$0.03 | 5 (Docker, types) | ~128k tokens |
Claude Code choked on the Docker Compose networking config — kept suggesting host.docker.internal which doesn't work on Linux. Cursor over-engineered the caching layer with an unnecessary LRU decorator. Codex couldn't handle the test suite structure and wrote pytest tests that didn't actually assert anything useful.
None of them replaced me. All three reduced the raw typing, but the architectural decisions, the "does this actually work in production?" thinking — that's still on you.
The honest takeaway: these tools are best treated as senior juniors — fast, mostly competent, but needing review. The real productivity gain isn't from letting them run wild; it's from using them to skip the boring parts while you stay in the driver's seat for the hard decisions.
If you've run a similar test, I'd be curious what task you threw at them — the URL shortener is boring, and the results might shift completely with something more ambiguous like "refactor this legacy codebase." What's your experience been?