Build1 publisher3 min readPublished
The study counts only complexity and dead code, because those are the two pyscn metrics that stay exact when you analyze just the files a patch touched. The human's own commit trips the same rule 24% of the time.
The Engineer · Build desk

Compiled by The EngineerSomething wrong?How this is made
A delta needs a baseline. "+3 complexity" says nothing on its own, so each model patch is scored against the human commit that closed the same issue: check out the base commit, measure the files the patch touches, apply it, measure again, subtract [5]. The human diff runs through the identical pipeline and trips the same regression rule on 24% of instances [8]. That is the number worth holding onto. It says the bar is low enough that ordinary human bug fixes clear it about one time in four, and the models still fall the other side of it more often [2].
Only two of pyscn's metrics are in play, and the reason is partial-repo analysis rather than convenience. Cyclomatic complexity and dead code both fall out of the control-flow graph of one function in one file, so they stay exact when you analyze a subset; coupling, cohesion and clone detection undercount whatever the unread files would have contributed, which would make the score depend on which files the patch happened to open [6]. Two housekeeping rules follow from the same problem. Files present on only one side are excluded, because a file with no before-state inflates every delta it lands in, and a deletion books a whole file's complexity as an improvement [9]. Scoring is restricted to patches that passed their tests, which cuts against the finding rather than for it: ungated, the sample roughly doubles and eleven models clear Bonferroni instead of six [10].
The headline count is a sign test. Thirteen worse, one tied, none better is p = 0.00024 against a coin flip [11]. Per model it thins out: twelve of fourteen clear p < 0.05 alone, six survive Bonferroni across the fourteen comparisons [12], so six are significant only until you correct for having looked fourteen times [4]. The disagreements are where the effect is legible. On 741 issues exactly one side regressed, and the model was that side on 530 [14], leaving 211 the other way [1], about 2.5 to 1 [3].
The file litter is a different mechanism from the complexity. An agent writes throwaway scripts as it works, reproduce_bug.py, check_url_parts.py, final_verification.py, and the final patch is a git diff, so anything still sitting in the working tree ships with the fix [16]. A file named final_verification.py arriving on main has not verified much. Human patches create 0.00 files the model's does not, while models reach 5.00 [17]. Under a second framework, gpt-5 leaves 0.07 and claude-opus-4.5 leaves 0.00, against kimi-k2 at 3.84 [19], roughly fifty-five times gpt-5's rate in the same harness [5]. Those files cannot be what produced the complexity result: a new file has no before-state, so the exclusion rule drops it from the delta [6].
What does not transfer is the ranking. The biggest gap belongs to devstral-small, near the bottom of the leaderboard, with gpt-5 second, both on OpenHands; across the seven models sharing an identical framework there is no trend, with o3 and o4-mini above claude-sonnet-4 and qwen3-coder-480b [15]. Django alone gave three worse and two surviving correction, and the other eleven repositories mostly bought statistical power [13]. For this to carry to your repo you need Python, acceptance that cyclomatic complexity and pyscn's high-risk rating stand in for health [3], work shaped like closing an issue on an existing project [1], and a harness that emits the working tree as a diff [16]. The patches are public leaderboard submissions the authors downloaded rather than ran [4], so the hygiene being measured is partly the submitter's harness settings.
The gate this evidence supports is narrow and has two checks: files absent from the base commit get rejected unless the diff explains them, and the complexity delta on the edited functions gets read against what the fix actually required. Every result set is committed, so both halves can be rechecked against your own thresholds [20].
Ranked by verification strength, evidence, and original report placement.
The bugs and human fixes come from SWE-bench: 500 closed issues from open-source Python projects, each keeping the repository as it was before the fix along with the commit that closed it.
Thirteen of the fourteen models tested raised a function's complexity or added dead code more often than the person who fixed the same bug. One tied. None did better.
Measurement used pyscn, the authors' own Python analyzer, which reports cyclomatic complexity, dead code, duplicate code, class coupling and cohesion, and module dependencies; the study used two of them, complexity and dead code.
The model patches are public leaderboard submissions, which the authors downloaded. No model was run for the study.
For each (issue, patch) pair: git checkout base_commit, analyze the files the patch touches for a before measurement, git apply the patch, analyze the same files for after, delta = after - before; the human's commit for the bug is measured the same way.
Only complexity and dead code count because both come from the control-flow graph of one function in one file and stay exact when analyzing part of a repository; coupling, cohesion and clone detection are not exact on a subset, undercounting what missing files would contribute, so the score would depend on which files the patch touched.
Follow any of these and your For You feed starts watching them — no settings page required.
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
One team's measurement, published in full
Everything rests on a single post written by the people who built the analyzer that defines 'messier'. What lifts it above a tool blog is that the procedure is given down to the git commands, the human baseline is printed at 24% rather than buried, and the result sets are committed for recounting. What is missing is a second party: nobody has re-run pyscn's ratings, and the per-model table behind the eighteen-fold spread is described rather than shown.
Single run over archived leaderboard entries
Nothing here has travelled beyond the authors' own run. The model side is downloaded leaderboard submissions — no model was executed for the study — and the newest of them, claude-opus-4.5, landed in November 2025, with part of the sample from May. Committed result sets make replication cheap; a replication by anyone else is not in evidence.
Narrow metrics, broad adjective
'Messier' is a wide word for two numbers read off a control-flow graph, which the authors concede near the end. The regression rule fires on a single added branch, the human's own commit fires it on 24% of instances, and only six of fourteen models hold up after correction across the fourteen comparisons — so the 13-of-14 framing carries more weight than the statistics under it. The overshoot stays small because every deflating figure is in the same post.
The ruler is the authors' product
pyscn is the authors' own analyzer, the study's definition of worse code is whatever pyscn can measure exactly, and the post doubles as a demonstration of the tool. Working against that reading, though: keeping the test-pass gate costs them five models' worth of correction-surviving results, and reporting the human baseline at 24% undercuts a cleaner story they could have told.
Legible method, narrow scope
The method is specific enough to argue with, which is why this sits above what a lone self-published source usually earns. The weaknesses are scope rather than rigour: Python only across twelve repositories, one attempt per model set against patches that passed review and CI before merging, and a sample whose newest entry predates the post by roughly ten months.
build
SWE-Gate flunks 221 of 644 test-passing agent patches on rules mined from PR comments1 publisher
build
YipitData tests a $2.5B-$3B sale, and the price is on the data, not the code1 publisher
build
Mutation scoring drops a 47% coverage test to a 9.5% kill rate1 publisher
build
A JSON parser benchmark that scores refusal as a pass, and why the column order flips1 publisher
Publishers with included, body-backed reporting in this cluster.
1 article · September 6, 2026