Pathmode vs. Linear

Linear and Pathmode overlap more than they did a year ago, and the overlap is worth naming plainly.

Linear drafts the work now, not just the ticket. Draft Projects (September 2026) added a composer where you develop an idea with the Linear Agent before creating a live project: "Create with Agent" pulls context from the workspace and connected tools to sharpen the brief and build out a plan. Team Docs gave the workspace a knowledge home. Loops runs recurring agent workflows, and since September 14 a loop can react to project, initiative, cycle, and issue changes and edit the relevant Linear document so the plan keeps up with scope and timing. Coding Sessions write code, Diffs review it, Code Intelligence answers questions about the codebase. Anyone comparing entry points will see two products where an agent writes the first draft from a one-line brief. That much is genuinely similar, and Linear has the distribution.

The difference is where the decision lives, and what that makes possible. The repository gets the decision. Pathmode keeps the evidence and the authorization behind it.

Residence. Pathmode's intent is a file in the repository the coding agent builds from, versioned with the code and readable by any agent, as a file or over MCP. A Linear brief lives in Linear. Since September, Loops can keep it in step with the project, editing the plan when scope or dates move. Every trigger is activity in the Linear workspace, though, and none of them reads the code, so the brief tracks the project while it drifts from the codebase over the following quarter.

Authorization of the exact revision. Because the intent is a file, a decision can be bound to one version of it. A person reviews the proposal from a link, without opening the repository, and sends corrections back to the agent that wrote it. When the result is right, they authorize that exact revision, and an agent working through Pathmode checks the authorization covers the current file before it builds. If the file changes afterwards, the earlier authorization no longer covers it, and Pathmode flags the revision as undecided.

Verification. When a pull request opens, Pathmode grades the diff against the intent and cites the code it relied on. Linear's Diffs review the code, and Code Intelligence explains the code, but neither checks the code against the brief that asked for it.

Anchoring, underneath all three. Every requirement in an IntentSpec points at the signal that justified it, a quote, a metric, an observation. Pulling context in to sharpen a brief is not the same thing: the context informs the prose and then stops being addressable. A drafted brief in Pathmode quotes the signal it was seeded from, and cannot anchor itself to an assumption.

Open suggestions, a narrow point about the hosted editor. Linear shipped text attribution in July 2026: author indicators tell you whether a line came from a colleague, the Agent, or a Loop, agent edits highlight separately for review, and the attribution persists through version history. Who typed a line is a solved problem in Linear. In Pathmode's hosted editor, an agent-added claim lands unresolved and stays that way until a person keeps it, edits it, or removes it, and an agent writing through the API cannot clear that state for itself. A label you can read, against a state someone has to clear. Intents that live in the repository are revised through reviewed changes instead.

A quarter later. Code Intelligence can tell you what the code does. The questions that come up after a project closes are different. Which version of the decision was authorized, and by whom? What evidence stands behind this requirement? Does the code that shipped still honor it? A brief holds the conclusion. It does not hold the evidence behind each requirement, or whether the shipped code still honors it.

They compose. Pathmode produces the intent and verifies the result. Linear schedules the work, runs the agents, and ships it. Pathmode's MCP server is a grounding source Linear's agents can read from, so the drafting surface you like keeps working against an artifact that remembers.

Scenario: customers keep abandoning onboarding at the workspace-creation step.

With Linear alone, a PM opens the project composer and types the problem. The Linear Agent pulls context from the workspace and connected tools, sharpens the brief, and builds a plan. The PM likes it and creates the project. A Coding Session ships a redesigned form, conversion moves four points, and a Loop keeps the plan current as the dates shift. Two things are then unrecoverable. Nothing checked whether the shipped form kept the email-domain validation the plan called for. And the plan lives in Linear, not beside the code, so the next agent to change the form from the repository never reads it.

With Pathmode upstream, the coding agent writes its proposal as intent.md in the repository. The PM reviews it from a link, without opening the repo, and sends two corrections: rewrite the objective, and remove an edge case the agent invented. The agent applies them, and the PM authorizes that exact revision. Each requirement points at the signal behind it: a metric ("42% drop-off at workspace creation"), three customer quotes ("I didn't know what to put in the workspace name"), a session observation ("users hesitate on the slug field"). The constraint about email-domain validation for B2B accounts is written down with its reason attached.

The coding agent builds from the authorized file. When the pull request opens, Pathmode grades the diff against the intent and cites what it read: "the shipped change does not enforce email-domain validation on workspace creation." The PM sees it before the merge, not in a support ticket six weeks later.

Next quarter, an agent edits intent.md to loosen that constraint. The PM's authorization covered the earlier revision, not this one, so Pathmode flags the file as undecided until someone decides it.

Linear ships the work. Pathmode is what the work is answerable to.