Software engineering, checked · Part 11 of 13
Machines: AI, checked (version 1)
In 2023, a group of researchers gave developers one small, well-defined programming task and split them in two. Half had GitHub Copilot. The half with the AI pair programmer finished 55.8% faster. The number has been quoted ever since.
In 2025, METR ran a randomised trial with experienced open-source developers, working on their own codebases. With AI tools allowed, they took 19% longer. Afterwards, the same developers estimated that AI had made them about 20% faster ~85 %. They weren't novices. They were experienced developers, and they couldn't tell the difference between being helped and being slowed down.
A warning before anything else. This is the part of the series that will age fastest. It was written in November 2026, mostly from studies of tools released between 2022 and 2025, and the tools have changed since every one of them was run. The ratings here will be re-rated first, and some will move within a year. The question is plain: what have AI tools changed in software engineering, so far?
Where does 55% come from?
The 55.8% is a real result from a real randomised experiment. It is also one bounded task, set in a lab, with a clear finish line. That is close to the best case for a code generator. Real work comes with an existing codebase, colleagues' conventions and review. As a claim about how much faster developers are at their work, it rates poorly ~30 %.
The number travelled for the same reason the 100x curve and the 189% did. It was precise, it came from a credible source, and it said what a lot of people wanted to hear. The caveat, that it measured one task of one kind, stayed in the paper.
What field trials show
The trials closer to real work land lower. At Google, a randomised trial with 96 engineers found that developers with AI were about 21% faster, though the estimate missed statistical significance in the study's full model. Three field experiments at companies, pooling 4,867 developers, found 26% more completed tasks, with a wide margin of error. Taken together: about a fifth to a quarter, in enterprise settings, with intervals that could hide a much smaller gain ~70 %. Then there is the METR result, which went the other way.
Why would developers keep using a tool that doesn't speed them up? Because they like it. In an early Copilot study of 24 people, users finished no faster and had trouble debugging the generated code, but most still preferred it for daily work, because it gave them a starting point and saved searching online ~70 %. Preference is a legitimate reason to use a tool. It is not a measurement of speed.
Where does the time go? In 21 labelled Copilot sessions from 2022, the largest single activity was checking the AI's suggestions, at 22.4% of the time. About half of all session time went to work the assistant itself created ~70 %. The sample is small and the tool is old. The mechanism is not: whatever the machine writes, somebody has to read.
This is the series' third thread in its sharpest form. The feeling of speed comes from the moment the code appears. The cost arrives later, spread across reading, checking and fixing, where nobody is timing it.
Copy-paste, all over again
Insecure code borrowed from somewhere else is not a new problem. In 2017, Felix Fischer and colleagues analysed 1.3 million Android apps. 15.4% contained security-related snippets copied from Stack Overflow, and 97.9% of those included at least one insecure one. Another study found 99 vulnerable C++ snippets on Stack Overflow reused in 2,859 GitHub projects ~85 %. The question is whether AI suggestions repeat the pattern.
The first famous number here is 40%. In 2022, Hammond Pearce and colleagues gave Copilot 89 scenarios and got 1,689 programs back; about 40% were vulnerable. But the scenarios were built to invite the worst-known weaknesses. A replication with a newer Copilot found the share falling from 36.5% to 27.3%, and a study of Copilot code in real GitHub projects found weaknesses in about a quarter of snippets ~70 %. Smaller than 40%; still a lot. And working is not the same as safe. Two 2025 benchmarks that run real exploits found about half of the working backends exploitable, and one agent's solutions to real tasks were 57% functionally correct but only 11.8% secure ~85 %.
Does the developer using the tool write less secure code? Two small user studies disagree. With an assistant, 47 participants wrote less secure code on security tasks in Python and JavaScript; 58 students working in C produced critical security bugs no more than 10% more often than those without ~50 %. The first study found something more worrying than the code itself: the people with the assistant were more likely to believe their code was secure. Other studies point the same way, with users missing wrong answers or leaving with an illusion of competence ~70 %.
Then there is a failure Stack Overflow never had. Across 576,000 code samples from 16 models, AI recommended packages that don't exist in at least 5.2% of commercial-model outputs and 21.7% of open-source ones. 43% of the invented names came back in all ten repeats of the same prompt, which means an attacker can predict them, register them and wait ~85 %.
The benchmark mirage
Most of what is said publicly about AI's coding ability comes from benchmarks, and SWE-bench, a set of real GitHub issues, is the best known. Its scores overstate what agents can do ~85 %. When researchers removed issues whose solutions had leaked into the issue text or whose tests were too weak, one early agent's resolution rate dropped from 12.47% to 3.97%. On the cleaned-up Verified subset, weaknesses in the tests still inflate reported rates by about 6.4 points. Part 12 comes back to why benchmarks drift like this.
The better test is what happens when an agent's work meets a maintainer. In a study of 456,000 pull requests opened by coding agents on GitHub, acceptance trailed human pull requests by 15 to 40 percentage points, most of all for features and bug fixes. Results differ a lot by tool: in a sample of pull requests made with Claude Code, 83.8% were merged, though only 54.9% of those without further changes ~70 %. Software is people talking, and a pull request is an argument a maintainer has to accept. The stopwatch on the benchmark doesn't capture that conversation.
What does move fast is the length of task an agent can finish. METR's measurements show that horizon doubling about every seven months since 2019, perhaps faster since 2024. The fine print matters: the trend counts tasks completed half the time, on well-defined problems. At 80% success, the horizons are four to six times shorter, and messier tasks fare worse ~70 %. This is the trend most likely to make the rest of this part out of date.
And speed now may cost later. Open-source projects that adopted Cursor sped up for about two months, while static-analysis warnings and code complexity rose and stayed up. A preregistered experiment, though, found AI-assisted code no harder for other developers to change ~50 %. Genuinely open.
Learning with a machine at your elbow
In a randomised trial at Anthropic, developers learning a new library with AI help scored 17% lower on a quiz about it afterwards, and were not significantly faster. A study of 69 novices aged 10 to 17 found no such loss, and the harm depended on how people used the AI ~70 %.
Who gets hurt matters too. The usual finding in AI productivity studies is that the less experienced gain most. An eye-tracking study of 21 programming students saw something less comfortable: those who were doing well used AI to go faster on code they already meant to write, while those who struggled were led astray and finished believing they had done better than they had ~50 %. It is small and qualitative, a warning rather than a result. It is also exactly the gap a team lead would never see from a pull request.
Where it clearly helps
Some uses hold up well. At Meta, a tool called TestGen-LLM proposed improvements to existing unit tests, and engineers accepted 73% of them for production. The figure is high because every candidate had already been filtered: in one evaluation, only 75% of generated tests built, 57% passed reliably and 25% increased coverage. The model wrote; the filters decided ~85 %.
Explaining code is the other clear win. In a course of about 1,000 students, explanations written by a language model were rated easier to understand and more accurate than the students' own ~85 %. That is one course and student ratings, but it points to a use of AI that doesn't involve writing your code for you.
Both uses share a shape. The output is cheap to check, either by a machine or by the reader's own understanding. Where checking is cheap, the tools pay. Where it is expensive, the cost shows up somewhere nobody is measuring.
What doesn't work
- Quoting the 55%. It was one bounded lab task; field trials land around a fifth, and one landed below zero ~30 %.
- Asking developers whether AI speeds them up. Experienced developers felt 20% faster while measuring 19% slower ~85 %.
- Treating 40% as the vulnerability rate. It came from prompts built to invite weaknesses; the real rate is lower and still high ~70 %.
- Choosing tools by benchmark score. Leaked solutions and weak tests inflate them, and agents' pull requests get merged far less often ~85 %.
Try this
- Measure, don't ask. If you want to know whether AI helps your team, compare cycle times or completed work on comparable tasks, not satisfaction surveys.
- Review AI code like Stack Overflow code. Assume a working snippet may still be exploitable, and give security-relevant code the same scrutiny you'd give an unknown author.
- Check every package before you install it. Confirm that a suggested dependency exists, is the one you meant and has a real history.
- Put a filter between the model and the main branch. Meta's tests were useful because each one had to build, pass reliably and add coverage before a human saw it.
- When learning something new, ask for explanations, not code. Write the code yourself until you could have written it without help.
19 claims checked
The evidence behind this article
Every claim above, rated by the chance it holds up against the research. Open one for the sources and their exact words.
- Aleithan, Haoran, Mohajer, Nnorom, Uddin, Wang (2024). SWE-Bench+: Enhanced Coding Benchmark for LLMs · Study
- Alshahwan, Chheda, Finogenova, Gokkaya, Harman, Harper, Marginean, Sengupta, Wang (2024). Automated Unit Test Improvement using Large Language Models at Meta · Study
- Borg, Hewett, Hagatulah, Couderc, Söderberg, Graham, Kini, Farley (2026). Echoes of AI: Investigating the downstream effects of AI assistants on software maintainability · Study
- Cui, Demirer, Jaffe, Musolff, Peng, Salz (2024). The Effects of Generative AI on High Skilled Work: Evidence from Three Field Experiments with Software Developers · Study
- Fischer, Bottinger, Xiao, Stransky, Acar, Backes, Fahl (2017). Stack Overflow Considered Harmful? The Impact of Copy&Paste on Android Application Security · Study
- Fu, Liang, Tahir, Li, Shahin, Yu, Chen (2025). Security Weaknesses of Copilot-Generated Code in GitHub Projects: An Empirical Study · Study
- He, Miller, Agarwal, Kästner, Vasilescu (2026). Speed at the Cost of Quality: How Cursor AI Increases Short-Term Velocity and Long-Term Complexity in Open-Source Projects · Study
- Joel, Rush, Barnes, David (2025). Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity · Study
- Kabir, Udo-Imeh, Kou, Zhang (2024). Is Stack Overflow Obsolete? An Empirical Study of the Characteristics of ChatGPT Answers to Stack Overflow Questions · Study
- Kazemitabaar, Chow, To, Ericson, Weintrop, Grossman (2023). Studying the effect of AI Code Generators on Supporting Novice Learners in Introductory Programming · Study
- Kwa, West, Becker, Deng, Garcia, Hasin, Jawhar, Kinniment, Rush, Arx, Bloom, Broadley, Haoxing, Goodrich, Jurkovic, Miles, Nix, Tao, Chris, Parikh, Rein, Sato, Wijk, M., Barnes, Chan (2025). Measuring AI Ability to Complete Long Software Tasks · Study
- Leinonen, Denny, MacNeil, Sarsa, Bernstein, Kim, Tran, Hellas (2023). Comparing Code Explanations Created by Students and Large Language Models · Study
- Li, Zhang, Hassan (2025). The Rise of AI Teammates in Software Engineering (SE) 3.0: How Autonomous Coding Agents Are Reshaping Software Engineering · Study
- Majdinasab, Bishop, Rasheed, Dakhel, Tahir, Khomh (2024). Assessing the Security of GitHub Copilot's Generated Code - A Targeted Replication Study · Replication
- Mozannar, Bansal, Fourney, Horvitz (2024). Reading Between the Lines: Modeling User Behavior and Costs in AI-Assisted Programming · Study
- Paradis, Grey, Madison, Nam, Macvean, Meimand, Zhang, Ferrari-Church, Chandra (2025). How Much Does AI Impact Development Speed? an Enterprise-Based Randomized Controlled Trial · Study
- Pearce, Ahmad, Tan, Dolan-Gavitt, Karri (2022). Asleep at the Keyboard? Assessing the Security of GitHub Copilot’s Code Contributions · Study
- Peng, Kalliamvakou, Cihon, Demirer (2023). The Impact of AI on Developer Productivity: Evidence from GitHub Copilot · Study
- Perry, Srivastava, Kumar, Boneh (2023). Do Users Write More Insecure Code with AI Assistants? · Study
- Prather, Reeves, Leinonen, MacNeil, Randrianasolo, Becker, Kimmel, Wright, Briggs (2024). The Widening Gap: The Benefits and Harms of Generative AI for Novice Programmers · Study
- Sandoval, Pearce, Nys, Karri, Garg, Dolan-Gavitt (2022). Lost at C: A User Study on the Security Implications of Large Language Model Code Assistants · Study
- Schäfer, Nadi, Eghbali, Tip (2023). An Empirical Evaluation of Using Large Language Models for Automated Unit Test Generation · Study
- Shen, Tamkin (2026). How AI Impacts Skill Formation · Study
- Spracklen, Wijewickrama, Sakib, Maiti, Bimal, Murtuza (2024). We Have a Package for You! A Comprehensive Analysis of Package Hallucinations by Code Generating LLMs · Study
- Vaithilingam, Zhang, Glassman (2022). Expectation vs. Experience: Evaluating the Usability of Code Generation Tools Powered by Large Language Models · Study
- Verdi, Sami, Akhondali, Khomh, Uddin, Motlagh (2020). An Empirical Study of C++ Vulnerabilities in Crowd-Sourced Code Examples · Study
- Vero, Mündler, Chibotaru, Raychev, Baader, Jovanović, He, Vechev (2025). BaxBench: Can LLMs Generate Correct and Secure Backends? · Study
- Wang, Pradel, Liu (2026). Are “Solved Issues” in SWE-bench Really Solved Correctly? An Empirical Study · Study
- Watanabe, Li, Kashiwa, Reid, Iida, Hassan (2026). On the Use of Agentic Coding: An Empirical Study of Pull Requests on GitHub · Study
- Zhao, Wang, Zhang, Jiaxuan, Li, Li (2025). Is Vibe Coding Safe? Benchmarking Vulnerability of Agent-Generated Code in Real-World Tasks · Study