Why Linear Loses the Plot When People Move On
Every project is a web of concepts that shape each other. Linear flattens that web into lists.
Some context can't be flattened without loss: why we chose this approach, what risks we accepted, how one team's bet reshapes another's roadmap. Most of it lives in people's heads.
"The world is made of circles. And we think in straight lines." Peter Senge
Organized work, missing context
Linear is an issue tracking tool that organizes execution into issues, projects, cycles, initiatives, and triage. But the reasoning behind that execution – why this was prioritized, what trade-offs were accepted, which teams are affected if plans change – lives wherever someone happened to type it, if they typed it at all.
Someone asks: "This initiative has 40 issues across three teams. If we slip the API deadline by two weeks, which of those issues are actually affected?" Or: "We made a technical decision six months ago that constrained this feature's scope. Where is that recorded?" Nobody can easily answer from Linear alone.
Linear's issue relations are structurally thin – blocks, relates, duplicates. They can't distinguish "this task achieves that goal" from "these two things are vaguely related." The context that would explain the difference never makes it into the system.
Every team has that person – the one whose departure exposes what the project management software never captured. When they leave or go on vacation, the context leaves too.
What changes when context is structure, not just memory
Bother models context as a typed graph – concepts like decisions, risks, and goals are distinct objects with named relationships, including dependencies. Some of that context has shape: dependency chains, cascading risk, cross-team impact. You can't see those patterns in a list. So the interface is a map you navigate, where connections are visible and traceable. The reasoning survives the people who created it because it's structure, not memory.
What this means in practice
A new engineer joins. Linear shows her everything that's been planned and assigned. What it can't clearly show: why the team pivoted away from the original architecture, which constraints shaped the current approach, or which goal this project is actually serving.
She opens the graph and sees the shape of the work: her task, the decision that shaped the approach, the goal the team is driving toward, all connected. She zooms out and the cross-team dependencies are right there. On her first day, she has the context it used to take months to absorb.
"Why did we rebuild auth instead of extending the existing system?" Linear has project documents, but they're free-form – there's no structure that makes rationale findable. So the reasoning lives in a Slack thread from March, a paragraph buried in a project update, or the head of the engineer who made the call. When she moves to another team, the reasoning goes with her.
You open the decision and see the evaluation laid out: what options were considered, what criteria mattered, what was ruled out and why. The goals it serves and the risks that informed it are right there, connected. The reasoning outlasts the person who made the call.
An initiative turns "at risk." What does that actually mean? You open each sub-project, read updates, cross-reference timelines, try to work out which issues are the real exposure and which teams get hit downstream. Linear gives you a health indicator and a text update. The structural picture you build yourself, and by the time you have, it's already shifted.
A risk has real structure: likelihood, severity, what it threatens. When the likelihood changes, you trace the chain: through the projects it feeds into, to the teams that will feel it. You see the cascade before it lands, and you act before it becomes someone else's surprise.
The layer Linear doesn't reach
When someone asks "why are we doing it this way?", the answer should be a path you can follow – from the task, through the decision that shaped it, to the goal behind it. That path should survive the people who created it.
Linear was built for a world where execution and context live in separate places. As a Linear alternative, Bother rejects the premise. Execution and context belong together.
Linear gives you lists. Bother gives you context.