Linear Says Issue Tracking Is Dead. Here's What's

There's something surreal about watching a company try to kill the thing that made them successful. Linear—the issue tracker that engineers actually like—just posted a manifesto essentially declaring that issue tracking is dead. Not dying. Dead.

And they're not wrong, but the replacement they're proposing raises questions they're not asking yet.

The Problem Everyone Knows But Nobody Fixes

Their argument starts with something most engineers already feel: issue trackers were designed for a world that doesn't exist anymore. Or at least, shouldn't exist anymore.

"Issue tracking was built for a handoff model of software development," Linear's announcement explains. "A PM would scope the work. Engineers would pick it up later and the system was filled with prioritization, negotiation, and workflows to bridge the gap."

That ceremony made sense when engineering time was the constraint. You needed elaborate systems to route work carefully across roles. But over time, the systems themselves became the work. Complexity started looking like sophistication. The more process a tool could absorb, the more "enterprise-ready" it seemed.

Theo from t3.gg—a developer with engineering experience at Twitch—puts it more bluntly in his video breaking down Linear's announcement: His Jira dashboard used to take over 2 minutes to load. Not because the software was fundamentally broken, but because it had been filled with so much interconnected complexity that the weight collapsed the whole thing.

Linear built their entire brand on the opposite philosophy: remove overhead so teams can focus on building. They succeeded by betting that engineers, not product managers, would drive tool adoption at their companies. Turns out they were right—Linear is now used at a comparable scale to Jira but with significantly higher adoption among startups.

So why kill it now?

AI Agents Change the Economics

Linear's data tells a story that's hard to ignore. Coding agents are now installed in over 75% of their enterprise workspaces. Not just hobby projects—actual enterprise customers. In the last three months, the volume of work completed by agents grew 5x. And agents are now authoring nearly 25% of new issues.

Those aren't small numbers. They represent a fundamental shift in who—or what—is doing the work.

"Planning, implementation, and code review begin to compress as agents absorb more of the procedural work," Linear's announcement states. "You can spend more time on intent, judgment, and taste and less time managing the mechanics of the process."

This is where it gets interesting. Theo describes a workflow he used at Twitch that sounds a lot like what Linear is proposing: instead of writing elaborate specs upfront, he'd build a rough prototype in 1-3 days, identify technical challenges through actual implementation, test it with users, and then write the spec. About half the time, they'd just polish the prototype and ship it.

"I never read a spec that was written before the product was made that even came close to describing what the product actually would be, how it should be implemented, and how long it would take," he says. "It was almost always entirely inaccurate."

AI agents make this approach accessible to everyone. You don't need to be exceptionally fast at prototyping anymore—the agent handles that part. Which means the entire "write detailed spec → assign to engineer → wait weeks → discover the spec was wrong" cycle can collapse.

What Linear Is Actually Building

Linear's vision replaces the traditional issue tracker with what they're calling a "shared product system" (their words, not mine—it's a pretty corporate phrase for a company that's usually more human).

Instead of organizing around issues and sprints, it organizes around context and agents. Customer feedback, internal ideas, strategic direction, decisions, and code all live together. The system understands intent, routes work to the right actor—human or AI—escalates when needed, and keeps execution moving.

They've launched three new features to get there:

Linear Agent: Does work directly against your product context
Skills: Codifies repetitive patterns so agents can reuse them
Automations: Triggers agent workflows automatically when issues arrive

The automations piece is particularly telling. Theo noticed something unexpected: while developers mostly ignore automation features, non-developers are going wild with them. He knows someone at a startup—never coded before—who now has 30+ automations running, doing everything from monitoring brand mentions across the web to auto-reporting them in Slack.

"To normies, this is the first time they could automate part of their life or work," he observes. Developers already know how to automate things; they also know it's usually more work than it's worth. So they've trained themselves not to bother unless it's genuinely valuable. People without that learned resistance are just... automating everything.

The Uncomfortable Questions

Here's what Linear's announcement doesn't address: what happens when the boring, procedural work disappears?

The optimistic view is that engineers get to focus on the interesting parts—intent, taste, architecture, the things that actually require human judgment. Agents handle the grunt work of implementing tickets, writing boilerplate, updating documentation.

The pessimistic view is that we're about to discover how much of software engineering was the boring, procedural work. And that the market for engineers who are only good at that part is about to get significantly more competitive.

Theo hints at this tension when he notes that the developers he sees using AI agents most heavily tend to be the less skilled ones. That's not an insult—it's an observation about who benefits most from tools that automate implementation. The developers who were already fast at building don't need the help as much. The ones who struggled with the mechanics suddenly have a level playing field.

That's genuinely democratizing! It's also going to change what companies value when they hire.

Linear's betting that the future looks like smaller teams building faster with AI assistance, where the constraint is good taste and clear intent rather than engineering hours. They might be right. But if they are, the entire job market for software engineers is going to reorganize around that reality.

The issue tracker isn't dying because we found a better way to track issues. It's dying because we're not going to have issues anymore—we're going to have context that directly becomes code. Whether that's better depends entirely on who you are and what you're good at.

Tyler Nakamura is Buzzrag's Consumer Tech & Gadgets Correspondent