PRs Went From 21 to 65. Nobody Got Their Time Back.

TL;DR

Linear published Edition 01 of its data report, built on aggregated telemetry from its own product rather than a survey. Three findings matter. AI now writes just under half of everything created in Linear. Teams that connected a coding agent went from 21 weekly pull requests to 65 over two years, while teams without one crawled from 8 to 10. And the total time those teams spend on product development went up, because AI work stacked on top of the existing work instead of replacing it. Linear calls this a Jevons paradox quality. You can also call it your review queue.

What was actually measured

This is product telemetry, not a self-reported survey, which makes it more honest about behavior and less honest about intent. The cuts are large enough to take seriously:

• Adoption by function: 127,000 paid users active in both January and June 2026.
• Pull request volume: 47,900 paid workspaces as of June 2026, with a June 2024 baseline.
• Coding agent comparison: 6,887 paid teams, split 4,280 with a connected coding agent and 2,607 without.
• Time allocation: 54,300 paid users in June 2025 growing to 89,000 in June 2026.

Everything below is Linear counting things that happen inside Linear. Hold that thought, it comes back in the caveats.

The gap between agent teams and everyone else

Pull requests across the whole population are up 111 percent in two years. That headline hides the actual split: nearly all of the growth is concentrated in teams that wired an agent into their repo.

A 6.5x gap in raw PR count between agent and non-agent teams is the single most quotable number in the report, and it is also the one most likely to be misread. It measures pull requests opened. It does not measure pull requests merged, and it says nothing at all about lines that survive to the next quarter.

AI authors nearly half the tickets

The other half of the story is upstream of code. Linear counts issues created by agents and MCP clients separately from issues created by people and integrations, and the two lines have almost converged. In the report's words, teams now use AI to write just under half of everything created in Linear, and at the current pace it will soon author more than people and integrations combined.

Adoption climbed in every function between January and June 2026, and the steepest climb was not in engineering.

A CEO quadrupling their AI usage inside the issue tracker in six months is either a leadership indicator or a pressure indicator, and the data cannot tell you which. Commenters on the Hacker News thread leaned hard toward the second reading.

The finding the vendor buried

Here is the line that should reset your roadmap assumptions. Time spent on existing tasks in Linear held steady while AI usage appeared as a new layer of work, meaning overall time spent on product development is going up rather than down.

That is not a productivity win with a lag. That is a new column in the timesheet. Think of it like adding a second lane to a highway that ends in the same single toll booth: cars per minute entering the road doubles, cars per minute leaving it does not move, and now you have twice as many drivers idling and furious.

The toll booth is code review.

Where the throughput goes to die

LinearB (a different company with a confusingly adjacent name, engineering analytics rather than issue tracking) ran the merge-side numbers in May 2026 across 8.1 million pull requests from 4,800 teams in 42 countries. Their result explains Linear's flat clock almost perfectly.

LinearB also found AI-assisted PRs run over 400 lines at the 75th percentile versus 157 for unassisted work, with agentic PRs around 290. Bigger diffs, longer queues, lower merge rate. The agent is not producing more shipped software, it is producing more inventory.

The two datasets were collected independently, by unrelated companies, three months apart, and they point at the same wall. That is the part worth trusting.

Caveats, because this is vendor telemetry

Read the report with these in hand:

• Linear only sees Linear. If your team uses an agent through a CLI and never touches an MCP client, none of that work shows up. Adoption is a floor, not a level.
• PR counts require repo integration. Some of the 111 percent growth is more workspaces connecting their git provider over two years, not more code.
• Activity is not outcome. Issues created, PRs opened, and executives clicking AI buttons are all inputs. Nothing here measures shipped value, defect rate, or revenue.
• Selection effect on agent teams. Teams that wire up a coding agent are probably already the higher-throughput teams. The 21 to 65 jump is a correlation with a plausible mechanism, not a controlled experiment.
• The vendor benefits from the conclusion. Linear sells the surface all of this activity happens on.

What to actually do with this

If your team is on the agent side of that chart, the bottleneck moved and your metrics probably did not follow it. Three concrete moves:

• Stop measuring PRs opened. Track merged-within-7-days and time-to-first-review. Those are the two numbers that moved in the wrong direction.
• Cap agent diff size. A 400-line agent PR sits for 16 hours because nobody wants to start it. Force the agent to land work in reviewable slices and the queue drains.
• Budget review capacity like compute. Tripling generation while holding reviewer headcount flat is a capacity plan, and it is the one that produced this result.

The uncomfortable read is that two years of coding agents have moved the constraint from writing code to trusting code, and nobody has shipped a product for that yet.

Key Takeaways

• Linear's first data report covers 47,900 paid workspaces and finds AI now authors just under half of everything created in the tool.
• Teams with a connected coding agent went from 21 to 65 weekly pull requests over two years; teams without one went from 8 to 10.
• Total time spent on product development went up, not down: AI work landed as a new layer on top of existing work rather than replacing it.
• LinearB's independent 8.1 million PR dataset shows AI-generated PRs merge within 30 days only 32.7 percent of the time versus 84.5 percent for human-written code.
• AI-generated PRs wait more than 16 hours for a first reviewer against roughly 200 minutes for unassisted work, and run over 400 lines at the 75th percentile.
• Both datasets are activity metrics from interested vendors. Treat direction as strong and absolute levels as soft.

Sources: Linear, AI usage patterns in software teams (Edition 01), LinearB, 8 million pull requests reveal where engineering productivity breaks down, Dev Interrupted, Why AI-assisted PRs merge at half the rate of human code, Hacker News discussion