AIHow we use AI in our process Learn moreabout how we use AI in our process

Why Frontier Coding Models Still Fail: What Expert Evaluation Finds That Benchmarks Miss

Why Frontier Coding Models Still Fail: What Expert Evaluation Finds That Benchmarks MissWhy Frontier Coding Models Still Fail: What Expert Evaluation Finds That Benchmarks Miss

AI coding models now pass most tasks on the best-known coding benchmarks, and their scores keep going up. Yet give the same model code it has never seen, and it still gets a lot of the work wrong. If you build, test or buy these models, you need to know why AI coding models fail on real work.

Our engineers write coding tasks for the newest AI models every day, and a big part of the job is finding where those models break. Below we explain why benchmark scores look better than real results. You will also see which mistakes we find most often and how we prove them.

Key takeaways
OpenAI stopped using its own best-known coding benchmark in February 2026, because models had already seen many of its tasks during training.
Even when AI code passes a benchmark’s tests, real project maintainers would reject about half of it, according to a March 2026 study by METR.
In our tests, AI models most often fail on business rules and on edge cases a developer who knows the product would cover without being told.
A typical failure looks convincing, because the model follows half the rules in the task and makes up the rest.
To prove a failure, we run each task 5 to 10 times and write down what went wrong and what the correct code looks like.

Benchmark Scores vs Real Coding Work

A coding benchmark gives a model a task from a public project and checks whether its code passes the tests. In real work, the model gets code it has never seen, and its code has to do everything the task asks.

What is checkedPublic coding benchmarkExpert evaluation
Where tasks come fromPublic GitHub issues from 12 open-source Python projects*New tasks written by senior software engineers
When a task counts as solvedThe automated tests passEvery requirement in the task is met
How many times each task runsOnce in most published scores5 to 10 times
Who checks the resultAn automated scriptA senior engineer with a correct solution in hand
What a failure tells youThat a test failedWhich rule broke, where, and how often

*Number of projects in SWE-bench Verified, as reported by METR in March 2026.

A benchmark is useful for comparing models with each other. To know whether a model’s code is ready to ship in your product, you need an expert review, so plan for it from the start.

Test your model on unseen tasks
Our senior engineers write new coding tasks and show where your model breaks.
Contact us

How Contamination Makes Models Remember the Answer

SWE-bench and similar benchmarks take their tasks from open-source projects on GitHub, and models learn from that same public code. So there is a good chance the model has already seen the task, and even the fix, before the test. A high score then says more about its memory than its skill, and this is what people call coding benchmark contamination.

OpenAI created SWE-bench Verified in 2024, and it became the most quoted coding benchmark. In February 2026 OpenAI found that the frontier models it tested could repeat the original answers to some of its tasks word for word. Models that had seen a task before were also more likely to pass it. So OpenAI stopped reporting SWE-bench Verified scores and asked other model developers to stop too.

Researchers from Purdue University and Microsoft found the same thing in a different way. They showed models only the bug description, without the code, and asked which file had the bug. On SWE-bench Verified tasks the models guessed right up to 76% of the time, while on other projects the figure fell to 53%.

You cannot fully clean this up, because the public code and its fixes stay online and end up in new training data. So read any score on a public benchmark as a best case, and test the model on tasks it could not have seen.

All Tests Passed, but Reviewers Still Rejected the Code

Automated tests only check that the code runs and gives the expected output. They do not check whether it does everything the task asks, follows the project’s rules or breaks something else.

In March 2026 the research group METR tried a simple experiment. It gave 296 AI-written code changes to 4 people who maintain the scikit-learn, Sphinx and pytest projects. Every change had passed the benchmark’s tests, yet the maintainers would not accept about half of them.

The maintainers rejected code for bad style, for breaking other parts of the project, or for not fixing the problem at all. METR notes that the AI had only 1 try with no feedback, while a human developer gets feedback and tries again.

Benchmark tests: all passed. Project maintainers: about half of the same AI code changes rejected

Tests can also make the opposite mistake. When OpenAI checked 138 hard tasks from SWE-bench Verified, at least 59.4% had tests that rejected correct code. Passing the tests is only the first check, and you still need a person to review the code against the whole task.

Why AI Coding Models Fail on Tasks Our Engineers Write

In the tasks our engineers write, AI coding models fail most often on business rules and on edge cases. A developer who knows the business logic and the system’s limits handles these cases without being told, and we expect the same from a frontier model.

These are the 3 mistakes we see with every frontier model our team tests most often:

Business rules

The code runs and looks tidy, but it breaks a rule written in the task. Say a subscription service gives 20% off annual plans, and that discount never stacks with a referral credit. The model applies the 20% correctly and then subtracts the referral credit too. Every test with a single discount passes, and the mistake only shows up in the next revenue report.

Edge cases

The task does not list them, but a developer who knows the product would handle them without being asked. Imagine a task to split a yearly contract into 12 monthly invoices, each due on the same day as the start date. The code works for a contract that starts on 1 March. For a contract that starts on 30 January, February gets no invoice because it has no 30th, and the client is billed for 11 months instead of 12. Anyone who has built billing before checks month ends first.

Invented logic

The model follows half the rules from the task and invents the other half. Say the task describes a refund flow with 6 rules. The model implements the first 3 as written, drops the rule about partial refunds and adds its own rule that refunds over €500 need a manager’s approval. The code is clean, commented and even has tests for the rule it made up, so a quick review would pass it.

A refund flow where the model's code follows three rules, misses the partial refunds rule and invents an approval rule for refunds over €500
Oleksandr Sainchuk
What worries us most is code that looks correct. The model implements some of the rules from the task and quietly replaces the rest with its own. If you don’t check every rule against the task, you won’t notice.
Oleksandr Sainchuk, Lead Developer

Public research shows the same picture. In September 2026 a new benchmark called Real-SWE came out, built on private code from real companies that models have not seen. The best AI agent solved only 38.8% of its tasks, many of them about billing and tax rules. So when you write test tasks for a coding model, put your business rules and edge cases into them, because that is where models fail.

Let us break your model first
Get each failure with repeated runs, a written reason and the correct solution.
Contact us

How Expert Evaluation Proves a Failure

We run each task 5 to 10 times and count a failure only when it happens again. For each confirmed failure, the engineer writes the reference answer we expected the model to give. Next to it goes the evidence, where the engineer explains why the model went wrong. One bad run can be chance, but a repeated mistake with a reference answer and evidence attached is something a lab can fix.

The same task run 10 times: the model fails most runs, so the failure is confirmed

Human evaluation of code generation takes longer than an automated check, so we make sure every result is hard to argue with. This is how our engineers work through each set of tasks.

  1. Agree on the rules. We agree on what counts as a failure, which topics to cover and in what form we send the results.
  2. Write new tasks. Senior software engineers write tasks the model has not seen, based on business rules and edge cases from real projects.
  3. Run each task 5 to 10 times. This shows whether a failure is stable or a one-off.
  4. Write the evidence. For each failure, the engineer notes which requirement broke, where in the code, and why the model most likely got it wrong.
  5. Write the reference answer. The engineer writes the answer we expected from the model, then compares the model’s answers with it and with each other.
  6. Get a second review. Another senior engineer checks the failure, the evidence and the reference answer.
  7. Hand over the data. The confirmed failures, evidence and reference answers go to the lab to train the next version of the model.

OpenAI used the same logic in its own check of SWE-bench. It marked a task as unsolved only after its model failed it again and again over 64 runs. So whenever you report a failure, say how many runs you did and how often it happened.

What Benchmarks Are Still Good For

Public benchmarks are still useful for comparing models on the same tasks and for seeing how fast they improve. Use them to make a shortlist, not as proof that a model works on real code. METR says the same and describes its own study as one piece of evidence.

The search for a better public benchmark shows SWE-bench limitations well. In February 2026 OpenAI suggested SWE-bench Pro as a replacement. In July 2026 it checked that benchmark too, found about 30% of its tasks broken and took the suggestion back. OpenAI’s view now is that good benchmarks need tasks written and checked by experienced software engineers.

Benchmarks built on private code, like Real-SWE, are the next step, because their code and answers are not online. When you see any coding score, ask 3 things. Where did the tasks come from, how many tries did the model get, and could it have seen the answers before?

What This Means for Teams Building or Buying Coding Models

AI labs get the most from new tasks written by experts that models have not seen. Product teams get more from a test set made from their own code and cases, and both need failures they can repeat and check.

For a lab, the useful result is a steady flow of hard tasks with confirmed failures, a written reason for each and the correct solution. That shows where the model breaks and gives the next round of training something concrete to learn from.

Say you’re an engineering lead at a fintech company in London, choosing a coding assistant for 40 developers. Take a few dozen finished tickets from your own codebase and keep the ones with business rules. Run each model on them several times and ask a senior engineer to review the code. You can evaluate an LLM on your own data the same way for any AI feature.

How UITOP Runs Expert Evaluation

Our senior software engineers write tasks that make the newest coding models fail, and they prove each failure with repeated runs. For every failure, the lab gets a written reason and the correct solution. A team of 60 engineers works on this, and designers join when the task is to build an interface.

For AI labs and model teams, we work as a dedicated team paid monthly, at an average rate of €40/h. If your product runs on GPT, Claude or Gemini, an evaluation starts from €6,400 and takes from 4 weeks.

Our AI model evaluation team finds where your model breaks. You get failures you can repeat yourself, with the reason and the correct answer for each one.

Test a model on your own tasks
Find out where the model breaks before you build your product on it.
Contact us

Benchmarks Measure Progress; Experts Find the Failures

A failure is proven when it keeps happening on a new task from a senior engineer, with the reason and correct solution on record. A benchmark score cannot show that, so use scores to pick a shortlist and then test the shortlist on work the models have never seen.

If you run an AI lab, start with new tasks in the areas where your model is weakest. If you are choosing a model for your product, build a small test set from your own tickets and run it before you sign.

Share this article:
Questions and answers

FAQs

Is SWE-bench still a reliable benchmark?

It is still useful for comparing models, but it does not show how a model handles new code. OpenAI stopped reporting SWE-bench Verified in February 2026, because models had seen its tasks and some tests were wrong. Its replacement, SWE-bench Pro, has about 30% broken tasks.

What is benchmark contamination?

Benchmark contamination means the test tasks or their answers ended up in the model’s training data. The model then remembers the answer instead of solving the problem, so its score looks better than its real skill. Coding benchmarks built on public code have this risk by design.

Why do AI models pass tests but fail code review?

Tests only check that the code runs and fixes the reported case. A reviewer also checks every requirement, the project’s rules and whether anything else broke. In METR’s March 2026 study, maintainers would not accept about half of the AI code that had passed the tests.

How do expert evaluators find model failures?

They write new tasks the model has not seen, with business rules and edge cases, and run each task several times. A failure counts when it happens again and comes with a written reason and a correct solution that a second senior engineer has checked.

Can we test a coding model on our own code?

Yes, and it gives the most honest result. Take finished tickets from your own codebase, write down what a correct fix must do, run each model several times and review the code. UITOP runs this as an evaluation from €6,400, taking from 4 weeks.