\n
\n By Vilius Vystartas | May 2026<\/p>\n
Every LLM can write code that works. The question is: can they write code that’s efficient \u2014 and does telling them to be efficient actually help?<\/p>\n
I tested 10 models on 10 coding tasks, each in two phases: unprompted (the model writes its own code) and prompted (explicitly told to write clean, DRY, efficient code). That’s 200 API calls, $0.56 total. The results are… not what most prompt engineers would predict.<\/p>\n
GPT-5.4 was the only model where prompting gave a substantial boost (+0.20). For most models, the “write efficient code” prompt was meaningless or actively harmful.<\/p>\n
How the Metric Works<\/p>\n
Each task has a known optimal token budget \u2014 the minimum tokens needed to produce correct, DRY code for that task (e.g., 70 tokens for 10 styled buttons using CSS classes vs 340 tokens for 10 separate button blocks). The efficiency score is optimal_tokens \/ actual_tokens, capped at 1.0.<\/p>\n
A score of 0.63 means the model used about 1.6x the optimal \u2014 not bad. A score of 0.43 means it used about 2.3x the optimal. The gap between unprompted and prompted tells you whether the “write efficient code” instruction actually changes behaviour.<\/p>\n
The Leaderboard (Sorted by Prompted Efficiency)<\/p>\n
#
\nModel
\nUnprompted
\nPrompted
\n\u0394
\nFrugal
\nCost
\nCorrectness<\/p>\n
\ud83e\udd47
\nGPT-5.4
\n0.43
\n0.63
\n+0.20
\n30%
\n$0.096
\n78% \u2192 85%<\/p>\n
\ud83e\udd48
\nQwen 3.6 Plus
\n0.44
\n0.60
\n+0.17
\n40%
\n$0.158
\n78% \u2192 87%<\/p>\n
\ud83e\udd49
\nGemma 4 31B
\n0.54
\n0.58
\n+0.04
\n50%
\n$0.003
\n92% both<\/p>\n
4
\nDeepSeek Chat
\n0.51
\n0.55
\n+0.04
\n30%
\n$0.006
\n91% \u2192 80%<\/p>\n
5
\nClaude Sonnet 4
\n0.47
\n0.52
\n+0.04
\n40%
\n$0.121
\n92% both<\/p>\n
6
\nLFM 2 24B A2B
\n0.54
\n0.47
\n-0.06
\n30%
\n$0.001
\n90% \u2192 80%<\/p>\n
7
\nMistral Large 2411
\n0.54
\n0.46
\n-0.08
\n40%
\n$0.050
\n90% \u2192 82%<\/p>\n
8
\nGemini 2.5 Flash
\n0.47
\n0.46
\n-0.01
\n50%
\n$0.020
\n92% \u2192 90%<\/p>\n
9
\nCohere Command A
\n0.60
\n0.44
\n-0.17
\n40%
\n$0.071
\n90% \u2192 82%<\/p>\n
10
\nKimi K2.6
\n0.34
\n0.43
\n+0.09
\n30%
\n$0.029
\n76% \u2192 86%<\/p>\n
What Stands Out<\/p>\n
GPT-5.4 Is the Prompt Whisperer<\/p>\n
GPT-5.4 improved on 7 of 10 tasks when prompted for efficiency. The biggest wins were config-generation (+0.81 \u2014 went from 12 inline JSON blocks to a template loop), html-from-data (+0.71), and magic-strings (+0.38 \u2014 switched to an Enum). It’s the only model in the batch where the “write efficient code” instruction consistently produces different (and better) output.<\/p>\n
The cost is notable \u2014 $0.10 for 20 tasks is mid-range, not cheap, not expensive. But the efficiency gain is real.<\/p>\n
Gemma 4 31B: The Quiet Winner<\/p>\n
Half of Gemma 4’s tasks were already “frugal” \u2014 naturally efficient without being told. It scored 92% correctness on both phases at just $0.003 total. That’s a 40x cost advantage over GPT-5.4 with higher correctness and competitive efficiency. For high-volume production where you want concise, correct code, Gemma 4 31B is the value pick of this batch.<\/p>\n
Cohere Command A: Prompting Backfires<\/p>\n
Cohere Command A had the highest unprompted efficiency in the batch (0.60) \u2014 it naturally writes concise code. But when told “write efficient code,” it ballooned output on several tasks. html-from-data went from a tight 45-token solution to a 600+-token monstrosity (-0.92 gap). The prompt made it overthink.<\/p>\n
Lesson: if a model is already efficient, don’t prompt it to be more efficient.<\/p>\n
Qwen 3.6 Plus: Second Place, Slowest<\/p>\n
Qwen 3.6 Plus scored second in prompted efficiency (+0.17 improvement) but took 26 minutes for 20 tasks \u2014 by far the slowest model. The efficiency gain is real (especially on html-from-data where it went from hardcoded rows to a map\/join pattern), but you’re waiting for it. Batch workloads only.<\/p>\n
The Kimi Surprise<\/p>\n
Kimi K2.6 had the lowest unprompted efficiency (0.34 \u2014 verbose, boilerplate-heavy code) but improved the most at the bottom end (+0.09). Still last place, but the prompt actually helped it compress \u2014 which is the opposite of the Cohere effect. Some models need the nudge.<\/p>\n
Frugality: What Does It Mean?<\/p>\n
“Frugal” means the model naturally produced code at or near the optimal token count without being asked. Gemma 4 31B and Gemini 2.5 Flash led at 50% \u2014 half their tasks were already efficient. GPT-5.4, DeepSeek Chat, and Kimi K2.6 were only 30% frugal \u2014 they needed the prompt to tighten up.<\/p>\n
The Bigger Picture<\/p>\n
Group
\nModels
\nBehaviour<\/p>\n
Prompt-responsive
\nGPT-5.4, Qwen 3.6 Plus
\nEfficiency improves substantially with prompting<\/p>\n
Prompt-neutral
\nGemma 4 31B, DeepSeek Chat, Claude Sonnet 4, Gemini 2.5 Flash, Kimi K2.6
\nPrompt has little effect (\u00b10.04)<\/p>\n
Prompt-antagonistic
\nLFM 2 24B A2B, Mistral Large 2411, Cohere Command A
\nEfficiency drops when prompted<\/p>\n
The prompt-antagonistic group is the most interesting. These models know how to write efficient code (0.54-0.60 unprompted), but the explicit instruction triggers over-engineering \u2014 they add abstractions, comments, error handling, and other bloat that makes the output less efficient by the metric.<\/p>\n
If the prompt says “write efficient code” and the model responds by writing more tokens, something in the training signal is misaligned.<\/p>\n
My Picks<\/p>\n
Best prompted efficiency: GPT-5.4 \u2014 0.63, $0.10 for 20 tasks. The only model where prompting reliably improves output.<\/p>\n
Best value overall: Gemma 4 31B \u2014 0.58 prompted, 92% correctness, $0.003. Absurd price\/performance.<\/p>\n
Best natural efficiency: Cohere Command A \u2014 0.60 unprompted. Don’t prompt it, just let it work.<\/p>\n
Most consistent: Claude Sonnet 4 \u2014 92% correctness on both phases, small +0.04 efficiency gain. Reliable.<\/p>\n
Skip if you’re in a hurry: Qwen 3.6 Plus \u2014 26 minutes for 20 tasks. Great efficiency gains, terrible latency.<\/p>\n
Watch list: Kimi K2.6 \u2014 low base efficiency but the prompt actually helps. Worth retesting with a better prompt.<\/p>\n
Methodology<\/p>\n
Ten real-world coding tasks across CSS, JavaScript, Python, SQL, and bash \u2014 each with a known optimal token budget for a correct, DRY solution. Tasks included: styling 10 buttons (CSS), rendering 20 data rows as HTML (JS\/HTML), bulk renaming (shell), form validation (Python), parametrized tests (Python), unit conversion (Python), SQL reporting queries, config generation (JSON), magic string replacement (Python\/Enum), and middleware decorator pattern (Python\/Flask).<\/p>\n
Each model ran 10 tasks unprompted, then the same 10 tasks with an efficiency prompt appended. Scoring: efficiency_ratio = optimal_tokens \/ actual_tokens (capped at 1.0). Correctness scored against expected output patterns.<\/p>\n
Total cost: $0.56 for 200 API calls (10 models \u00d7 10 tasks \u00d7 2 phases). Temperature: 0.1. Max tokens: 600.<\/p>\n
Full results: benchmarks.workswithagents.dev<\/p>\n