# Trends #12: We ship 3x more code and review it the same way — retained record

> Retained news record from news:ml-tech-world-with-milan-newsletter.

Canonical: https://highsignal.app/data/records/b77a866ac7d99192

[← sources](https://highsignal.app/data)


source: [news](https://highsignal.app/data/news) (news:ml-tech-world-with-milan-newsletter)  published 2026-10-15 15:02 ingested 2026-10-24 10:05

[original source ↗](https://newsletter.techworld-with-milan.com/p/trends-12)

## extract

The Trends filter tracks tech trends: what moved, why it matters, and what to watch next. If you spot a signal I missed, reply with a link and one line of context.
Today, we cover:
- Linear’s report on coding agents. Teams with agents went from 21 to 65 PRs a week, teams without from 8 to 10, and what is interesting is that no one saved any time.
- TypeScript 7.0. The Go port is out and the results are the following: VS Code builds in 10.6s instead of 125.7s. It is also interesting why they chosen Go over Rust.
- GitHub’s 8-hour outage. One of the worst GitHub outages happens recently, when one Istio sidecar hit its concurrency limit and a VS Code retry bug multiplied traffic 10. Still, monthly commits doubled since April, and now GitHub need to do something about it.
- InfoQ Cloud and DevOps trends. Where cloud agents, MCP and FinOps for AI are on the adoption curve, and why the next work is wiring tools together.
- InfoQ Culture and Methods trends. AI writes 42% of committed code and 96% of developers don’t trust it, so the engineer’s job moves to guarding it.
- METR on SWE-bench. Maintainers at scikit-learn, Sphinx and pytest reviewed 296 AI PRs that passed the benchmark, and merge rates came in 24 points below the grader’s score.
- DORA’s ROI of AI report. AI amplifies what your org already is: 35-40% gains on greenfield, 10% or less on legacy code, and this is visible in all our projects we worked on in past two years.
- Cursor’s Developer Habits report. Lines per week doubled, and the top 1% of developers now produce 46x more than the median.
So, let’s dive in.
How to Serve a Fleet of Small Open-Source Models (Sponsored)
Swapping a frontier model for specialised open models sounds like an easy win. Until you’re juggling runtimes, idle GPUs and deployment tickets. Superlinked breaks down how to serve a fleet of small models efficiently, from sharing GPUs to batching requests, without turning every new model into an infrastructure project.
1. We now ship 3x more PRs when we use coding agents
Although we ship so many PRs than before our teams without them gained only 25%. And this is visible from the Linear report on how software teams work by using AI technologies. Linear analyzed data from their platform in the period from June 2024 to August 2026 and 199,000 users. 
Here are the main findings:
- Teams which use a coding agents create 65 PRs per week, from 21 before them, while teams without agents moved from 8 to 10
- AI now writes ~50% of all created in Linear
- Agents open ~2.4M issues weekly, and people ~2.5M, which is almost the same
- PMs who write code moved from 3% to 10%, and designers from 1% to 8%
- And overall PRs per workspace increased 111% in two years
What is most interesting here is that no one is actually saving any time. We still do what we did before, but now we got AI inside. So, total time we spend on product development actually went up, instead of going down.
The question here is are those 65 PRs per week really bringing 3x more value? Any refactoring will spend tokens while fixing bugs will not. Yet we can conclude that output is not the same as value created.
Their summarized the report by saying that AI has changed how teams execute far more than how they decide what to build. This means execution is no longer the problem, but deciding what to build is.
2. TypeScript 7.0 is released and is 10x faster
In March 2025, Microsoft decided to create a 10x faster TypeScript by porting the compiler to Go. Now, TypeScript 7.0 is released in July, and here are the most important numbers:
- VS Code (2.3M LoC), where full build moved from 125.7s to 10.6s (11.9x faster)
- Sentry (1.9M LoC) moved from 139.8s to 15.7s (8.9x)
- Playwright went from 12.8s to 1.47s (8.7x)
- First errors in the editor went from 17.5s to under 1.3s
- Memory usage is up to 26% less than before
Some teams that used this version mentioned important advancements. For example, Slack managed to improve type-checking in CI from 7.5 min to 1.25 min, and Canva team managed to see the first error after 4.8s instead of 58s before.
This version (7.0) is also a cleanup, meaning that the ES5 target is no longer there, and baseUrl also, while strict mode is on by default.
The thing that remained as not optimal is that there is no programmatic API until version 7.1, so if you are using Vue or Svelte, you still need TS 6 in the editor.
What is interesting here is that before porting it to Go, they tried with Rust. But they concluded that the borrow checker will not allow circular data structures, and their compiler is full of such structures. So they decided for Go.
In the image below we can see improvements in compile times.
3. GitHub had one of the largest outages, that took 8h to resolve
On August 17, GitHub services degraded significantly for a few hours, which affected many developers on the platform. At the peak of the outage, error rates were around 20%, while content download errors were 50%.
GitHub managed to restore most of the service within three hours, yet the GitHub Actions and Copilot Token Service didn't work for prolonged time.
All in all, it took almost eight hours to fix it properly. The impact was, on GitHub .com, PRs, Actions, Copilot and more.
Now, GitHub published a detailed root cause analysis (RCA) for the outage, and here is what we can learn:
- The immediate cause of failure was network saturation on load balancers in Central US, due to increased traffic, and this was caused by an Istio sidecar (a Kubernetes pod with multiple containers) which reached its concurrency limits and failed to auto scale correctly.
- Then failure spread to four HAProxy (reverse proxy which route TCP and HTTP traffic) nodes and degraded the gateway auth path
- Then clients made it even worse, as failed Copilot token calls entered retry loops and a latent retry bug in VS Code multiplied traffic by 10X. A service that usually has 7-9K requests per second, all of a sudden had 70-100K. GitHub stopped it by returning 403 at the load balancer.
And this was the second GitHub outage in a month. The main issue is that monthly commits grew from 1.4 to 2.9 billion since April, and 7.38 billion in September 2026, but the capacity didn't support this.
We cannot say that we didn’t expect this, especially taking into account what is happening with the usage of AI agents and people vibecoding software more and more.
Now, they decide to do something about it, as they figure out that storage and serving capacity was coupled. Each repo usually have five copies on the disk, and adding more replicas help with reads, but each replica need to be written on, and this makes slow pushes. So, they decide to keep authoritative repository data in Azure Blob Storage and add lightweight workers with cache, which are independent of durable replication.
4. The cost of AI goes beyond tokens
Recently we saw the latest InfoQ report on Cloud and DevOps topics. Here are the most interesting findings:
- AI gents for cloud engineering move to early adopter from Innovator. Agents are moving from chat-only space to action-based scenarions. AWS and Microsoft released DevOps agents, and Google added an agent sandbox to GKE. Yet companies are still struggling with governance and compliance.
- Model Context Protocol is in early majority. The protocol which was introduced by Anthropic in November 2024 is becoming a de facto standard for integrations with AI tooling. Now, the questions of it’s further development is mostly about security and identity.
- Platform engineering is also in early majority. At KubeCon, 70% of the audience said platform engineering is just a rename of DevOps. This years report note that we should just enable AI work and reduce shadow platforms, which means bulding no more portals.
- FinOps for AI is in the innovator stage. Spending tokens is not cheap and companies need to account this into their IT budgets. Today we can know what amount of tokens we spend, but we don’t know have this make any kind of positive outcome. A Tokenomics Foundation formed in late 2025 to work on exactly this gap.
- Sovereign cloud is also in the innovator stage. Europe companies, such as banks want their data to be at home, not “somewhere in some cloud”. Before this we saw many companies going to on-prem because of this.
- Reliability and resilience in cloud is in the late majority. We had examples of one AWS region which was off for six months this year. So multi-region design and operational readiness is no longer optional.
From here we can conclude that in the next period most work in the Cloud area will be around integrations, meaning that we need less tools, but wired properly, with AI inside the platform.
5. AI writes 42% of code, so developers’ job is now to guard it
Along with Cloud and DevOps Trends report, InfoQ released Culture and Methods Trends report for 2026, which also tell us in which direction software development teams continue to work on daily basis. They looked mostly at what is the impact of AI to culture, teams and roles in them.
Here are the key takeaways everyone should know:
- Engineer as custodian. Now engineers mostly need to manage AI agents, check their work, but also to build build guardrails around them. Custodianship already has a standard artifact, as many projects now include an AGENTS.md file.
- The verification gap. Sonar surveyed more than 1,100 developers and found that AI writes 42% of committed code, yet 96% of developers do not trust it. Only 48% always check it out before committing.
- Code volume exploded. GitHub had 1 billion commits in 2025 and now it has 275 million per week, which is around 14 billion this year. No one can review 14x more code with the same process as we used to do.
- One-pizza teams (or one pizza-slice teams). Two-pizza teams are becoming a two-person team, plus a bunch of agents. The report warns us that this could led to less diversity in thinking and also more burnout as we are working more than ever before.
- Accountability is the new seniority metric. The question is how much you can be accountable for, not how much you can ship. "It was AI" cannot be an excuse for a production incident.
What we can set here is a quality threshold that the agent cannot lower, set coverage levels, but also verification hooks that the agent cannot skip. The skill now goes from reviewing PRs to setting constraints (which we call a harness) for agents. This includes specs, tests, thresholds, and boundaries.
6. About half of the AI PRs that pass SWE-bench would not be merged into main
SWE-bench used an automated grader, where real projects use a maintainer who has to work with the code every day, and researchers from METR measured this gap. They gave AI-written pull requests to the people who own the repositories. Those maintainers reviewed them in an usual way.
Here are the results:
- 4 active maintainers from scikit-learn, Sphinx and pytest reviewed 296 AI-written PRs, where each one had already passed the SWE-bench automated grader.
- Merge rates came in 24.% points below the grader scores, when you adjust for how strict these maintainers are, and that adjustment matters. The same maintainers merged only 68% of the original human patches.
- They rejected code mostly for weak quality, for breaking other code, and for missing the real issue.
- By the grader, Claude Sonnet 4.5 handles work that takes a person about 50 minutes. By maintainer review, about 8 minutes.
They used 95 of the 500 SWE-bench Verified issues and 5 models released between mid 2024 and late 2025. Reviews happened in GitHub, and nobody told the reviewers which patches are written by people.
METR said that the agents had one attempt and no chance to answer feedback, in the way how developer would do. So this is not a limit on what agents can do.
This means a benchmark score tells you the tests pass buts not if that code can be in your codebase. This is exactly why we in our teams still check AI-written PRs first manually.
8. AI won't fix your engineering org, it will make it just more visible
That is the conclusion of the DORA's new ROI of AI-assisted development report. They say:
"AI serves as a powerful amplifier in software development. It magnifies the strengths of high-performing organizations and the dysfunctions of struggling ones."
And basically this means that if we give AI to a team with a good platform and clear ownership, it will make them faster, on the other side if we give it to a team with unclear boundaries and a bad review process, it will just make that chaos only bigger then before.
The report tried to measured it, and in greenfield tasks AI give 35-40% productivity improvement, while on legacy code it is 10% or less.
What most engineering leaders miss here is that the biggest returns do not come from faster creation of code, but from making less rework and enabling team to have more time than before.
There is also something they call J-curve we should be aware of, which basically says that productivity degrade before it goes up. DORA call that dip the tuition cost of transformation.
I’ve led engineering teams for over two decades, and every tool I saw said it will fix bad organization, but it just exposed it faster. The thing is that we should fix the system first, then buy the tools.
9. How AI is changing the way developers work
When we talk about AI coding we mostly focus on faster production of code. Cursor recently released their first Developer Habits Report talking about something more important and that is that the work itself if changing it shape.
Here are five findings from the data:
- Volume doubled, but the shape matters more. Lines of code added by developers per week doubled in a year, from 4.2k to 8.6k. Cursor say this is not an ideal measure, and they are right about it. Much better is that what we do is getting bigger and bigger. Lines of code per one PR are 2.5x larger year over year and big Prs (1,000+ lines change) went up from 8% to 14%.
- The gap between top and median developers is become larger. This means that top developers are getting more from AI. P99 developers produce 46x more lines than the median active developer and merge 15x more PRs. The Gini coefficient for AI lines is at 0.77, which is much closer to a steep income distribution than a flat one.
- Models now read much more than they write. The input-to-output token ratio more than doubled, from about 4.5x to roughly 11x. Input tokens are now over 90% of non-cache token volume. Models spend most of their effort building context before they can generate a line, and code quality tracks with it: accepted AI lines surviving past 60 minutes went from 76% to 81%.
- Cost varies more than output. Cost per agent request spans nearly 9x across model families, from $0.18 (Composer 2.5) to $1.57 (Opus 4.7). But cost per accepted line spans only about 7x, because more expensive models produce more accepted code per request. The cheapest model per request is not always the cheapest per line that ships.
- More changes skip the manual accept step. The amount of agent changes reaching commits without a manual diff-acceptance step grew more than 5x since January, from 7% to about 36%. That step is the in-editor accept click, not PR review. It measures how far developers trust an agent to do a change to commit, and that share rises as agents take on more work on their own.
Liked this issue? Click the 💜 like button. It helps more readers find it.
Have something to add or disagree with? 💬 Leave a comment. I read every one.
📔 The Laws of Software Engineering has passed 1,500 copies
56 laws across architecture, people, time, quality, scale, code, and decision-making. Each chapter covers what the law says, where it comes from, when it applies, and what it looks like in a real project.
More ways I can help you
- 🤝 1:1 coaching. One session on your hardest engineering or leadership problem. You leave with concrete next steps. 100+ coachees.
- 📱 You Can Build a LinkedIn Audience. The system behind my 400K+ followers, as a 6-module video course with 50 post ideas, swipe files, and a 30-page guide. 300+ members.
- 📚 The Ultimate .NET Bundle. 500+ pages on modern C#, ASP.NET Core, and patterns from 30 real projects, plus 200+ interview Q&As. 1,000+ engineers.
- 📄 Premium resume package. ATS-ready templates, cover letter, and AI prompts, built from 300+ interviews. 500+ people. Want my eyes on your CV instead? Resume reality check.
- ✨ Patreon. Every book, template, and future drop, plus early access. 2,000+ insiders.
📰 Want to reach 50,000+ engineers, founders, and CTOs? See the sponsorship options.
Know someone who should read this? Share it and earn my books and resources as your referrals grow.

## retained text (truncated)



```
The Trends filter tracks tech trends: what moved, why it matters, and what to watch next. If you spot a signal I missed, reply with a link and one line of context.
Today, we cover:
- Linear’s report on coding agents. Teams with agents went from 21 to 65 PRs a week, teams without from 8 to 10, and what is interesting is that no one saved any time.
- TypeScript 7.0. The Go port is out and the results are the following: VS Code builds in 10.6s instead of 125.7s. It is also interesting why they chosen Go over Rust.
- GitHub’s 8-hour outage. One of the worst GitHub outages happens recently, when one Istio sidecar hit its concurrency limit and a VS Code retry bug multiplied traffic 10. Still, monthly commits doubled since April, and now GitHub need to do something about it.
- InfoQ Cloud and DevOps trends. Where cloud agents, MCP and FinOps for AI are on the adoption curve, and why the next work is wiring tools together.
- InfoQ Culture and Methods trends. AI writes 42% of committed code and 96% of developers don’t trust it, so the engineer’s job moves to guarding it.
- METR on SWE-bench. Maintainers at scikit-learn, Sphinx and pytest reviewed 296 AI PRs that passed the benchmark, and merge rates came in 24 points below the grader’s score.
- DORA’s ROI of AI report. AI amplifies what your org already is: 35-40% gains on greenfield, 10% or less on legacy code, and this is visible in all our projects we worked on in past two years.
- Cursor’s Developer Habits report. Lines per week doubled, and the top 1% of developers now produce 46x more than the median.
So, let’s dive in.
How to Serve a Fleet of Small Open-Source Models (Sponsored)
Swapping a frontier model for specialised open models sounds like an easy win. Until you’re juggling runtimes, idle GPUs and deployment tickets. Superlinked breaks down how to serve a fleet of small models efficiently, from sharing GPUs to batching requests, without turning every new model into an infrastructure project.
1. We now ship 3x more PRs when we use coding agents
Although we ship so many PRs than before our teams without them gained only 25%. And this is visible from the Linear report on how software teams work by using AI technologies. Linear analyzed data from their platform in the period from June 2024 to August 2026 and 199,000 users. 
Here are the main findings:
- Teams which use a coding agents create 65 PRs per week, from 21 before them, while teams without agents moved from 8 to 10
- AI now writes ~50% of all created in Linear
- Agents open ~2.4M issues weekly, and people ~2.5M, which is almost the same
- PMs who write code moved from 3% to 10%, and designers from 1% to 8%
- And overall PRs per workspace increased 111% in two years
What is most interesting here is that no one is actually saving any time. We still do what we did before, but now we got AI inside. So, total time we spend on product development actually went up, instead of going down.
The question here is are those 65 PRs per week really bringing 3x more value? Any refactoring will spend tokens while fixing bugs will not. Yet we can conclude that output is not the same as value created.
Their summarized the report by saying that AI has changed how teams execute far more than how they decide what to build. This means execution is no longer the problem, but deciding what to build is.
2. TypeScript 7.0 is released and is 10x faster
In March 2025, Microsoft decided to create a 10x faster TypeScript by porting the compiler to Go. Now, TypeScript 7.0 is released in July, and here are the most important numbers:
- VS Code (2.3M LoC), where full build moved from 125.7s to 10.6s (11.9x faster)
- Sentry (1.9M LoC) moved from 139.8s to 15.7s (8.9x)
- Playwright went from 12.8s to 1.47s (8.7x)
- First errors in the editor went from 17.5s to under 1.3s
- Memory usage is up to 26% less than before
Some teams that used this version mentioned important advancements. For example, Slack managed to improve type-checking in CI from 7.5 min to 1.25 min, and Canva team managed to see the first error after 4.8s instead of 58s before.
This version (7.0) is also a cleanup, meaning that the ES5 target is no longer there, and baseUrl also, while strict mode is on by default.
The thing that remained as not optimal is that there is no programmatic API until version 7.1, so if you are using Vue or Svelte, you still need TS 6 in the editor.
What is interesting here is that before porting it to Go, they tried with Rust. But they concluded that the borrow checker will not allow circular data structures, and their compiler is full of such structures. So they decided for Go.
In the image below we can see improvements in compile times.
3. GitHub had one of the largest outages, that took 8h to resolve
On August 17, GitHub services degraded significantly for a few hours, which affected many developers on the platform. At the peak of the outage, error rates were around 20%, while content download errors were 50%.
GitHub managed to restore most of the service within three hours, yet the GitHub Actions and Copilot Token Service didn't work for prolonged time.
All in all, it took almost eight hours to fix it properly. The impact was, on GitHub .com, PRs, Actions, Copilot and more.
Now, GitHub published a detailed root cause analysis (RCA) for the outage, and here is what we can learn:
- The immediate cause of failure was network saturation on load balancers in Central US, due to increased traffic, and this was caused by an Istio sidecar (a Kubernetes pod with multiple containers) which reached its concurrency limits and failed to auto scale correctly.
- Then failure spread to four HAProxy (reverse proxy which route TCP and HTTP traffic) nodes and degraded the gateway auth path
- Then clients made it even worse, as failed Copilot token calls entered retry loops and a latent retry bug in VS Code multiplied traffic by 10X. A service that usually has 7-9K requests per second, all of a sudden had 70-100K. GitHub stopped it by returning 403 at the load balancer.
And this was the second GitHub outage in a month. The main issue is that monthly commits grew from 1.4 to 2.9 billion since April, and 7.38 billion in September 2026, but the capacity didn't support this.
We cannot say that we didn’t expect this, especially taking into account what is happening with the usage of AI agents and people vibecoding software more and more.
Now, they decide to do something about it, as they figure out that storage and serving capacity was coupled. Each repo usually have five copies on the disk, and adding more replicas help with reads, but each replica need to be written on, and this makes slow pushes. So, they decide to keep authoritative repository data in Azure Blob Storage and add lightweight workers with cache, which are independent of durable replication.
4. The cost of AI goes beyond tokens
Recently we saw the latest InfoQ report on Cloud and DevOps topics. Here are the most interesting findings:
- AI gents for cloud engineering move to early adopter from Innovator. Agents are moving from chat-only space to action-based scenarions. AWS and Microsoft released DevOps agents, and Google added an agent sandbox to GKE. Yet companies are still struggling with governance and compliance.
- Model Context Protocol is in early majority. The protocol which was introduced by Anthropic in November 2024 is becoming a de facto standard for integrations with AI tooling. Now, the questions of it’s further development is mostly about security and identity.
- Platform engineering is also in early majority. At KubeCon, 70% of the audience said platform engineering is just a rename of DevOps. This years report note that we should just enable AI work and reduce shadow platforms, which means bulding no more portals.
- FinOps for AI is in the innovator stage. Spending tokens is not cheap and companies need to account this into their IT budgets. Today we can know what amount of tokens we spend, but we don’t know have this make any kind of positive outcome. A Tokenomics Foundation formed in late 2025 to work on exactly this gap.
- Sovereign cloud is also in the innovator stage. Europe companies, such as banks want their data to be at home, not “somewhere in some cloud”. Before this we saw many companies going to on-prem because of this.
- Reliability and resilience in cloud is in the late majority. We had examples of one AWS region which was off for six months this year. So multi-region design and operational readiness is no longer optional.
From here we can conclude that in the next period most work in the Cloud area will be around integrations, meaning that we need less tools, but wired properly, with AI inside the platform.
5. AI writes 42% of code, so developers’ job is now to guard it
Along with Cloud and DevOps Trends report, InfoQ released Culture and Methods Trends report for 2026, which also tell us in which direction software development teams continue to work on daily basis. They looked mostly at what is the impact of AI to culture, teams and roles in them.
Here are the key takeaways everyone should know:
- Engineer as custodian. Now engineers mostly need to manage AI agents, check their work, but also to build build guardrails around them. Custodianship already has a standard artifact, as many projects now include an AGENTS.md file.
- The verification gap. Sonar surveyed more than 1,100 developers and found that AI writes 42% of committed code, yet 96% of developers do not trust it. Only 48% always check it out before committing.
- Code volume exploded. GitHub had 1 billion commits in 2025 and now it has 275 million per week, which is around 14 billion this year. No one can review 14x more code with the same process as we used to do.
- One-pizza teams (or one pizza-slice teams). Two-pizza teams are becoming a two-person team, plus a bunch of agents. The report warns us that this could led to less diversity in thinking and also more burnout as we are working more than ever before.
- Accountability is the new seniority metric. The question is how much you can be accountable for, not how much you can ship. "It was AI" cannot be an excuse for a production incident.
What we can set here is a quality threshold that the agent cannot lower, set coverage levels, but also verification hooks that the agent cannot skip. The skill now goes from reviewing PRs to setting constraints (which we call a harness) for agents. This includes specs, tests, thresholds, and boundaries.
6. About half of the AI PRs that pass SWE-bench would not be merged into main
SWE-bench used an automated grader, where real projects use a maintainer who has to work with the code every day, and researchers from METR measured this gap. They gave AI-written pull requests to the people who own the repositories. Those maintainers reviewed them in an usual way.
Here are the results:
- 4 active maintainers from scikit-learn, Sphinx and pytest reviewed 296 AI-written PRs, where each one had already passed the SWE-bench automated grader.
- Merge rates came in 24.% points below the grader scores, when you adjust for how strict these maintainers are, and that adjustment matters. The same maintainers merged only 68% of the original human patches.
- They rejected code mostly for weak quality, for breaking other code, and for missing the real issue.
- By the grader, Claude Sonnet 4.5 handles work that takes a person about 50 minutes. By maintainer review, about 8 minutes.
They used 95 of the 500 SWE-bench Verified issues and 5 models released between mid 2024 and late 2025. Reviews happened in GitHub, and nobody told the reviewers which patches are written by people.
METR said that the agents had one attempt and no chance to answer feedback, in the way how developer would do. So this is not a limit on what agents can do.
This means a benchmark score tells you the tests pass buts not if that code can be in your codebase. This is exactly why we in our teams still check AI-written PRs first manu
```



document fetched 2026-10-24 10:04