Why 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.
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 checked | Public coding benchmark | Expert evaluation |
|---|---|---|
| Where tasks come from | Public GitHub issues from 12 open-source Python projects* | New tasks written by senior software engineers |
| When a task counts as solved | The automated tests pass | Every requirement in the task is met |
| How many times each task runs | Once in most published scores | 5 to 10 times |
| Who checks the result | An automated script | A senior engineer with a correct solution in hand |
| What a failure tells you | That a test failed | Which 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.
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.

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.


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.
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.
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.

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.
- Agree on the rules. We agree on what counts as a failure, which topics to cover and in what form we send the results.
- Write new tasks. Senior software engineers write tasks the model has not seen, based on business rules and edge cases from real projects.
- Run each task 5 to 10 times. This shows whether a failure is stable or a one-off.
- 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.
- 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.
- Get a second review. Another senior engineer checks the failure, the evidence and the reference answer.
- 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.
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.




