We Loved Linear. We Just Didn't Have a Tracking Problem.

We were a happy Linear team — fast, keyboard-driven, beautiful. Then AI started writing most of our code, and a tracker stopped being the thing we were missing.

I want to be fair to Linear before I say anything else, because this isn’t a takedown.

Linear is the best issue tracker I’ve used. It’s quick in a way that feels almost rude next to Jira. The shortcuts are muscle memory inside a week. Cycles, triage, the small satisfaction of dragging an issue into Done — it’s genuinely lovely software, made by people who obviously care about the craft.

We used it. We liked it. And we still left.

Not because Linear got worse. Because the shape of our work changed underneath it, and no tool built on the old shape could follow.

Every tracker quietly assumes a human writes every line

Here’s the assumption sitting inside every issue tracker, Linear included: a person reads the ticket, a person writes the code, and the tool’s job is to show everyone where that person is in the queue.

That assumption held for fifteen years. It stopped holding for us the month AI agents started writing more than half of what we shipped.

The bottleneck was no longer “who’s working on what.” We could see that perfectly well. The bottleneck was that a ticket titled add refunds would get handed to an agent, and the agent — given three words — would confidently build the wrong thing, fast, and hand it back looking finished.

A prettier ticket doesn’t fix that. A faster keyboard doesn’t fix that. The gap isn’t in tracking the work. It’s in what the work is anchored to.

The truth of the work was never in the tracker anyway

Think about where the actual definition of a feature lives in a normal team.

A little in the ticket title. A little in a Slack thread from Tuesday. A little in a Figma comment. A little in the PR description, written after the code. The tracker holds the status of the work — todo, in progress, done — but it never held the truth of the work. It was never designed to. It points at the thing; it isn’t the thing.

For human teams that was survivable. People fill gaps with judgment and a quick DM. But when a machine writes the code, it fills every gap you left with a guess, and it does it at a speed that turns a small ambiguity into a merged mistake before anyone’s looked up.

So we didn’t need a better place to track tickets. We needed a single place to hold what done means — one that an agent could build against and a human could sign off on.

What we actually built instead

Bodhiorchard has one object at its center, and it isn’t a ticket. It’s a living document per feature — the spec, the design, the technical plan, the test plan, the pull requests, and the learnings when it ships, all in one place that evolves as the work does.

The agents build against that document. Not against a title. Not against a vibe from a standup. Against the thing everyone actually agreed to.

And — this is the part I care about most — the humans stay exactly where humans are irreplaceable. We learned the hard way that AI is brilliant at the routine 80% and quietly dangerous on the 20% that matters: the illegal state transition, the idempotency, the refund-on-a-refund nobody wrote down. So the people aren’t tracking cards while the machine works. They’re doing the judgment: writing the spec sharp enough to be worth building, and catching the 20% the agent will always get confidently wrong.

The tool’s job flipped. Linear told us the state of the work. We needed something that holds the substance of it.

This isn’t a fair comparison, and that’s the whole point

I’m not going to pretend Bodhiorchard is a better Linear. It isn’t trying to be. Linear is the finest tool in its category; we didn’t go looking for a faster tracker and find one.

We went looking and realised we’d been trying to solve an AI-native delivery problem with a human-native tracking tool. That’s not a bug in Linear. It’s a category that assumes the code comes from a person, running into a team where increasingly it doesn’t.

So the honest framing is: if you’re a team of humans writing human code, Linear is very likely still the right answer, and a tracker plus a little discipline will carry you a long way. I’d recommend it without flinching.

It’s the moment the machine starts writing the majority of your code that “just track it” starts to crack — because the thing you’re now missing isn’t visibility into people. It’s a source of truth the agents can build against, with your seniors guarding the parts that move money.

We didn’t replace Linear because it was bad. We replaced it because we stopped having the problem it solves, and started having a different one.

What’s the tool you’re still paying for that solves a problem you’re not sure you have anymore?