We gave four Claude models the same four coding jobs

The short answer

At max effort, all four models passed all 76 of our checks. At Claude Code's default effort, Haiku 5.5 and Opus 5.5 still passed all 76, while Sonnet 5.5 and Fable 5.1 each missed one: the same time zone case in the bug hunt, explained below.

The bigger difference was the bill. Haiku did the four jobs for $0.08 in 5.5 min at the default effort, against $0.86 and 25 min at max. Every model was 3 to 11 times cheaper at its default, and finished the four jobs in under 8 minutes instead of 25 to 47.

So for code like this, small and clearly specified, with a way to check the result, we would start with Haiku 5.5 at the default effort. When a slip would cost a client money, as with dates, prices or stock, we would either raise the effort or use Opus 5.5, which also passed everything at its default and was the quickest of the four there, for $1.41. Anthropic's own Claude Code help still calls Sonnet "the right choice for the large majority of coding work", and our four small jobs say nothing about the large changes that advice is mostly about.

The four jobs

We picked jobs we actually get from clients, wrote each as a short brief in a README, and gave every model a folder with the brief and the starting files. The examples (a bakery, a candle shop, a conference) are made up.

1. WordPress: an opening hours shortcode. A table of the week's hours from a settings field, "Open now" in the site's time zone, a Friday that closes at 2 am, a compact mode that merges days, and escaping, because three people edit the hours. 27 checks.
2. Shopify: a free-shipping progress bar. An Online Store 2.0 section with its settings schema, prices in cents, a threshold that can have cents too, a bar that stops at 100%, nothing at all for an empty cart, and the merchant's message escaped. 15 checks.
3. Webflow: a UTM script. Footer code that keeps where a visitor first came from and where they came from this time, in cookies, and fills hidden fields on every form, including a form that appears later in a popup. It must never throw, even with cookies blocked. 14 checks.
4. A bug hunt. A small ticket shop plugin "we wrote last year" and an email from the client: an early bird price still given after midnight, a discount code that took EUR 20 off instead of EUR 10, and "Sold out" with a ticket left. Find the causes, fix them, break nothing else. 20 checks, 9 of which already passed before the fix.

How we tested

We ran every test on 24 October 2026 in Claude Code (version 2.1.310), the way a developer at a studio would use it: the model gets a folder with the task, can read and write files and run commands, and says when it is done.

• The models. Haiku 5.5, Sonnet 5.5, Opus 5.5 and Fable 5.1, picked with Claude Code's model setting. Every response in the logs names the model that served it, so we know each run used the model we asked for.
• The same prompt for all. Each model got the same brief and the same short instructions; only the folder path differed, and the folders had random names, not model names. No web, no other agents, no advisor model.
• Two effort levels. Every model did every job twice. First at max, the highest setting. Then at Claude Code's default: medium for Haiku, Sonnet and Opus 5.5, and high for Fable 5.1. The logs record the effort of every step, so we know which runs used which.
• Hidden checks, written first. We wrote the checks before any model ran, tried them on a correct solution and on a deliberately sloppy one, and kept them encrypted until the runs of a job had ended. The models could write and run their own tests; they never saw ours.
• One run each. One run per model, job and effort level. A second run could come out differently.
• Cost is what the run's tokens cost at Anthropic's API prices, read on 24 October 2026, including Claude Code's own instructions (about 57,000 tokens at the start of every run, mostly read back from the cache after the first call). On a Pro, Max or Team plan you pay a monthly price instead, and the same numbers show how much of your usage a job takes.
• Time is from the first message to the last in the run's log.

The results

Checks passed, cost at API prices and time, per job. At max effort:

At Claude Code's default effort:

At max effort the table is really about the last two numbers: Haiku was the cheapest on every job and the quickest on three of the four, and Fable was the most expensive on every job but quicker than Sonnet and Opus on all four. At the default effort the order changed. Opus was the quickest in total, Sonnet close behind, and Fable became the slowest as well as the most expensive.

The one check two models missed

The client's email said the early bird price ended on 31 October, but a customer still got it at 00:30 on 1 November. The shop is in Amsterdam; the server runs on UTC. The old code worked out "the end of 31 October" in the server's time zone, so the early bird lasted an hour too long.

All eight runs found that cause. They fixed it in two ways:

• In the site's time zone. The deadline is the end of 31 October in Amsterdam, whatever time is passed in. All four models at max effort, and Haiku and Opus at the default, did this.
• In the time zone of the moment passed in. Sonnet and Fable at the default built the deadline in whatever time zone the "now" value happened to carry. That works when the shop passes Amsterdam time, which its own tests did. Pass the same moment as UTC, as code that reads a server clock might, and 00:30 on 1 November in Amsterdam still gets the early bird: the bug the client reported, back again.

Their own tests all passed, because they tested with Amsterdam times. Nothing in their hand-over notes mentioned the case. It is the kind of slip that only shows up in production, which is why we would raise the effort, or ask for a test with the time given in UTC, on anything that touches dates and money.

Where the money went

Two things decide the bill in a session like this:

• What the model writes, thinking included. At max effort most of it is thinking: about 85% of Haiku's tokens and 70% of Fable's. At the default, the models thought much less and wrote much less: Sonnet wrote about 18,000 tokens over the four jobs instead of 356,000.
• What it reads back. Every step re-reads the conversation so far, mostly from the cache at a fraction of the price. Fable's cache reads cost $0.25 per million, Opus's $0.20, Sonnet's $0.10 and Haiku's $0.01.

At max effort Fable wrote the fewest tokens, about 152,000 against 347,000 for Haiku, and still cost the most, because a token from Fable costs 100 times what one from Haiku costs: $50 per million output tokens against $0.50. At the default effort Haiku still wrote the most (about 63,000), but at its price that came to about two cents a job.

If you use Claude Code on a plan rather than the API, the dollars are not on your bill, but the proportions still show which model and which effort eat your weekly limit. Our guide to Claude for small business covers what each plan includes.

How they worked

The checks only tell you the code worked. The logs and the hand-over notes tell you how each model got there.

• They all reproduced before fixing. In the bug hunt each model first got the client's exact wrong numbers out of the old code (EUR 69.06 charged after EUR 86.33 shown), then fixed the cause. All eight runs found the same three causes: the deadline time zone above, a discount written back into the cart every time the totals were read, and a < that should have been <=.
• They wrote their own tests. For the bug hunt at max effort they added 11 (Haiku), 35 (Sonnet), 19 (Opus) and 20 (Fable) tests to the plugin's own test file; at the default, 19, 9, 10 and 17.
• The max-effort fixes were small. 20 changed lines of plugin code from Haiku, 23 from Opus, 28 from Fable and 31 from Sonnet.
• The folder rule. Every prompt said to work only inside the job's folder. At max effort one run strayed: Opus ran git status, which looked in the folders above for a repository (it found none and read nothing else). At the default effort four runs wrote a scratch file outside the folder: Sonnet twice (an empty file it said it made by mistake, and a test script it left behind) and Opus twice (a test script and a copy of the plugin to compare against, both deleted afterwards). None of them read anything outside, which we checked in the logs.
• Small slips. Fable changed the plugin's version number in the max-effort bug hunt, which nobody asked for.

The most useful part was what they raised without being asked. At max effort:

At the default effort the notes were shorter, but Haiku and Fable still said that orders already charged wrongly need a look, and Opus pointed out that two orders at the same moment could still both take the last ticket.

What this test does not show

• Other effort levels. We tried the highest setting and the default, not low, high or xhigh in between.
• Big codebases. Each job fit in one folder. A change across a large theme, a refactor or a long session that runs out of room is a different kind of work.
• Vague work. Our briefs were precise. The bug hunt's email was vague, but the code was small.
• Code quality beyond behaviour. The checks test what the code does, not how easy it is to read or change next year.
• One run each. Run it again and a model could fail a check it passed, or pass the one it missed.

Which model we would use

Pick the job:

If your studio runs client work on our board, Proofyard, the Claude connector uses whichever model you pick in Claude Code or claude.ai, so these choices carry over. Our other tests used the same method on web design, writing website copy and agent work on a project board. For what each model costs and which plan includes it, see which Claude model for which job, and for what Claude does inside our board, our pricing and the smart actions it runs.

The prompt we used

Every model got this, with only the folder changed. Try it on a job of your own:

Sources

• Our test runs, 24 October 2026: the briefs, starting files, hidden checks, run logs and results, kept with the test kit.
• Anthropic API pricing, read 24 October 2026.
• Claude Code model configuration (effort levels and defaults, model names), read 24 October 2026.
• Models, usage and limits in Claude Code, Anthropic's help article.