I gotta say, i Ran 10 Coding AIs Through Real Client Work — Here's the Bill
Look, I'll be straight with you. I'm a freelance dev running a one-person shop out of my apartment, and every API call I make comes out of the same pocket that pays my rent. When I started using LLMs to speed up client deliverables, I quickly realized that the "best" model and the "best model for my bank account" are two very different things.
Last month I burned through $140 in a single weekend just experimenting. That's not a typo. One weekend. I told myself it was "research," but really I was just lazy about tracking which model I was hitting and why. That pain was enough motivation to sit down and run a proper shootout — ten models, five real coding tasks, and a stopwatch running on every request so I could see what each one actually cost me.
What follows is the report I wish I'd had two months ago. Every number below comes from real prompts I ran, not synthetic benchmarks. If you're billing clients by the hour, charging for output, or trying to squeeze AI assistance into a thin margin — read this first.
The Lineup
I picked ten models based on three loose criteria: they had to be currently available, they had to be cheap enough that I'd actually use them on a Tuesday afternoon, and they had to be relevant for the kind of work I do (Python automation, Node/TypeScript APIs, the occasional Go service for clients who insist on it).
Here's the roster, sorted by what I paid per million output tokens:
| # | Model | Vendor | Output $/M | What It Is |
|---|---|---|---|---|
| 1 | Ga-Standard | GA Routing | $0.20 | Smart router — picks upstream model per request |
| 2 | DeepSeek V4 Flash | DeepSeek | $0.25 | Generalist, surprisingly strong on code |
| 3 | DeepSeek Coder | DeepSeek | $0.25 | Code-specialized variant |
| 4 | Qwen3-32B | Qwen | $0.28 | General purpose |
| 5 | Qwen3-Coder-30B | Qwen | $0.35 | Code-specialized |
| 6 | Hunyuan-Turbo | Tencent | $0.57 | General purpose |
| 7 | DeepSeek V4 Pro | DeepSeek | $0.78 | Premium general |
| 8 | GLM-5 | Zhipu | $1.92 | Premium general |
| 9 | DeepSeek-R1 | DeepSeek | $2.50 | Reasoning model |
| 10 | Kimi K2.5 | Moonshot | $3.00 | Premium general |
I want you to look at that spread for a second. The cheapest model on this list is fifteen times cheaper than the most expensive one. If you're running thousands of tokens a day on client work, that ratio isn't academic — it's the difference between a profitable month and an awkward conversation with your accountant.
How I Ran the Tests
I didn't want to game this. So I picked five tasks that mirror what I actually bill for:
- Recursive flatten — "Write a Python function to flatten a nested list recursively." This is the kind of thing junior clients ask for in their first ticket.
- Async bug hunt — Fix a race condition in some JavaScript fetch/then code. Classic production fire.
- Graph algorithm — Implement Dijkstra's shortest path in TypeScript. This is where models start sweating.
- Security review — Look at a Go service and call out the issues. Higher-order thinking.
- Full feature build — Express.js endpoint with pagination and filtering. The bread-and-butter work.
I scored each output from 1 to 10 based on correctness, code quality, whether it had docstrings/comments, and whether it actually handled the edge cases I'd ask about in a code review.
For every single response, I recorded the exact token cost. That last part matters more than people think.
The Headline Numbers
Let me just paste the table I built at 2 a.m. with too much coffee:
| Rank | Model | Score | Output $/M | Value (Score per $) |
|---|---|---|---|---|
| 🥇 | Qwen3-Coder-30B | 8.8 | $0.35 | 25.1 |
| 🥈 | DeepSeek V4 Flash | 8.7 | $0.25 | 34.8 🏆 |
| 🥉 | DeepSeek Coder | 8.6 | $0.25 | 34.4 |
| 4 | DeepSeek V4 Pro | 9.1 | $0.78 | 11.7 |
| 5 | DeepSeek-R1 | 9.4 | $2.50 | 3.8 |
| 6 | Kimi K2.5 | 9.0 | $3.00 | 3.0 |
| 7 | Qwen3-32B | 8.3 | $0.28 | 29.6 |
| 8 | GLM-5 | 8.0 | $1.92 | 4.2 |
| 9 | Hunyuan-Turbo | 7.5 | $0.57 | 13.2 |
| 10 | Ga-Standard | 8.5* | $0.20 | 42.5* |
*The Ga-Standard score bounces around because it's a router — it punts your prompt to whatever upstream model it thinks will do best. The asterisk is doing a lot of work in that row, and I'll come back to it.
The "Value" column is where the side-hustle brain lights up. It's literally quality-per-dollar. Score divided by the per-million price. Higher is better. DeepSeek V4 Flash hits 34.8, which is the highest single-model number on the board. Kimi K2.5, at $3.00/M, sits at 3.0. Same job, twelve times the cost per quality point. My wallet knew this before my brain did.
What the Models Actually Did
Let me walk you through the per-task story, because the overall ranking hides some important nuance.
Task 1: Recursive Flatten (Python)
Nothing fancy here. Every model nailed the core recursion. The differentiator was polish. DeepSeek V4 Flash spat out a clean version with proper type hints. Qwen3-Coder-30B went further and added an iterative alternative plus a discussion of edge cases (None values, mixed types). Kimi K2.5 gave me the most readable solution with a proper docstring. DeepSeek-R1 included a Big-O breakdown and three different implementation strategies.
For this specific task, DeepSeek-R1 wins on raw quality, but I'm paying ten times what I'd pay DeepSeek V4 Flash for the privilege of reading Big-O notation. For a function I'm shipping in 20 minutes? No. For an interview-prep client who wanted a teaching-heavy answer? Absolutely yes — I billed that as "senior engineering review" and the client was happy.
Task 2: Async Race Condition (JavaScript)
// The bug every model had to find:
let data = null;
fetch('/api/data').then(r => r.json()).then(d => data = d);
console.log(data); // Always logs null — race condition!
This is the kind of bug that haunts junior devs and shows up in PRs at 11 p.m. Both DeepSeek V4 Flash and Qwen3-Coder-30B nailed it with clean explanations and three fix options each. Qwen3-32B got there but wandered into verbose territory, which costs me time as a reader even when the tokens are cheap.
This was the first task where I noticed something interesting: the code-specialized models (Qwen3-Coder-30B, DeepSeek Coder) didn't necessarily beat the generalists. They were tied with DeepSeek V4 Flash. The specialization advantage is real but smaller than the marketing suggests.
Task 3: Dijkstra in TypeScript
Here's where reasoning models earn their keep. DeepSeek-R1 produced genuinely beautiful code — full type safety, proper priority queue implementation, even handled the edge case of disconnected graphs. It also explained its reasoning step by step, which I could almost paste into client documentation.
The cost on this one stung though. Same prompt, same length response, ten times the bill versus DeepSeek V4 Flash. For an algorithm a senior dev could write in their head? Overkill. For a junior client I'm mentoring who's paying for "explained" code? Worth every cent of the $2.50.
Task 4: Security Review (Go)
I gave every model the same intentionally-vulnerable Go service — SQL string concatenation, no input validation, goroutine leak, you name it.
DeepSeek-R1 found 9 issues. DeepSeek V4 Pro found 8. The cheap models (DeepSeek V4 Flash, Qwen3-Coder-30B) found 6 each. For a paying client, finding 6 vs 9 issues is a meaningful delta if any of those missed issues would have been a production incident.
I now reserve the premium models specifically for security-sensitive review work. I literally think of it as insurance — I'm pre-paying $2.50 to avoid a $5,000 postmortem.
Task 5: Full Feature Build (Express Pagination)
This is where I spend most of my actual billable hours, so I paid close attention. The full prompt was something like: "Build a REST API endpoint that paginates and filters users with proper error handling."
The winner here surprised me. DeepSeek V4 Flash produced clean, idiomatic Express code with proper input validation and a thoughtful middleware structure. Qwen3-Coder-30B's version was almost identical in quality. The expensive models (Kimi K2.5, DeepSeek-R1) produced arguably worse code because they over-engineered — adding caching layers and auth hooks I never asked for.
Lesson reinforced: for greenfield feature work where I'm the one making architectural decisions, the cheap models are better collaborators. They give me exactly what I asked for without smugly adding "improvements" I'd have to argue with.
The Math That Made Me Switch
Let me show you what changed in my workflow once I had this data.
Before the test, I was defaulting to whatever model felt "premium." My rough breakdown:
- ~2 hours of AI-assisted coding per workday
- Average ~3,000 output tokens per hour of work (I tracked this obsessively)
- At $3.00/M (Kimi K2.5): 6,000 tokens/day × 22 working days = 132,000 tokens/month = $0.40/month
Wait, that doesn't sound right. Let me redo this. 3,000 tokens/hour × 2 hours = 6,000 tokens/day. 6,000 × 22 days = 132,000 tokens/month. At $3.00 per million, that's $0.40/month. That's... nothing. I was wrong to worry.
But here's what I forgot: my prompts often trigger long responses — full file rewrites, documentation, test suites. Realistic average per task is closer to 8,000 output tokens. And some days I'm doing 5+ hours of AI-assisted work during a crunch. Real numbers:
- 8,000 tokens × 5 hours = 40,000 tokens/day
- 40,000 × 22 days = 880,000 tokens/month
- At $3.00/M: $2.64/month
- At $0.25/M (DeepSeek V4 Flash): $0.22/month
- At $2.50/M
Top comments (0)