What Your Coding Agent Can't See in the Code

Tom Moor, Linear21:13 · Nov 2026 · 2,587 views
Thumbnail for What Your Coding Agent Can't See in the Code Watch on YouTube
TL;DR
  1. 1

    Coding agents can produce code cheaply, but they still miss the product intent, past decisions, ownership, and risks behind that code.

  2. 2

    Linear carries context from intake through implementation and review with triage and review agents that inspect customer history, incidents, reverts, related work, and ownership.

  3. 3

    A daily automation turns corrections from merged pull requests into lessons in the codebase, so human judgment can guide later agents.

Summary

Tom Moor argues that software implementation is no longer the main constraint. Coding agents can run for hours or days and produce features at low cost, so the harder problem is keeping the product coherent. Agents can read the code, but they often miss why a decision was made, which trade-offs shaped it, how the product should feel, who owns the decision, and whether similar work caused an incident or revert. Linear addresses this by carrying context through the full workflow. A triage agent enriches incoming issues with customer information, logs, related work, and prior decisions. A review agent checks proposed changes against product history, reverts, regressions, incidents, overlapping work, and the original issue. A daily automation extracts lessons from review comments and merged changes, then adds them to agent instructions or related documentation. Moor's examples show this catching risks that ordinary code review could miss.

Key ideas
06:00

The software bottleneck has moved from implementation to coherence

Moor says coding agents make implementation cheap and increasingly autonomous, with tasks running for hours or days. The failure mode is no longer an inability to build. It is an inability to maintain a coherent product. He defines product quality through consistency, restraint, trade-offs, and many small decisions that reinforce one another. His example is a settings page that has accumulated options without a clear product judgment behind them. More generated code can therefore create a product that works in isolation while making less sense as a whole.

07:02

Code contains only part of the context an agent needs

A coding agent can read the code but may not know the intent behind it, the user problem, or the trade-offs that shaped the design. It may not know how the feature should look and feel in the product, whether another team is working on a related area, or who makes the final product decision. It can also miss historical risks, such as a revert that happened two weeks earlier. Moor's approach carries this information from the initial idea through planning, implementation, and review.

08:57

Triage turns a raw request into usable working context

Linear collects incoming ideas and problems from sources such as Zendesk, Slack, Teams, Gong, Twitter, product teams, executives, and Datadog alerts. Its triage agent labels, assigns, groups, closes duplicates, routes work, and asks for more information when needed. It investigates the issue and leaves the findings attached to it. The resulting context can include the requester, customer value, repeated requests, stack traces, Datadog logs, internal account IDs, related issues, and earlier decisions. That gives a human or coding agent a much better starting point than a short bug report.

11:11

Investigation can explain the cause instead of only locating code

Moor gives an example where captions kept turning on. The triage agent reproduced the bug and found that an automatic browser action was being mistaken for user intent. In another case, it searched the existing code, found similar shipped work, checked whether the issue was a regression, identified affected customers, and suggested where to start. These findings made automatic implementation more likely to address the actual problem rather than merely edit the nearest code.

12:16

Verification closes the loop during implementation

Moor spends less time on how agents write code because he considers that part relatively solved. He says the important pieces are a strong base context, the ability to verify the change, and feedback from CI failures. The agent needs to see whether its work passes the checks that matter. He points to Lauren at xAI, known on Twitter as potato, whose skills can help generate verification instructions for a coding agent. In his experience, context plus verification produces much better results for the team.

13:40

Review should ask whether a change fits the product

Linear's review agent starts with the original issue and its enriched context, then checks product history. It looks for previous decisions, reverts, regressions, and incidents in the same area. It also considers related issues, conflicting work, the full agent session, and ownership. Ownership matters because the person who should make a product trade-off may be a product lead, head of product, or CEO rather than someone who edited the code. Review therefore covers product fit as well as logical correctness.

16:01

Historical review catches problems that code-only review misses

Moor describes several recent examples. The review agent found changes from six and seven months earlier that marked a pattern as an incident risk because it held a database transaction open. It also surfaced a decision from a year earlier to remove busy UI, catching a pull request that tried to restore rejected iconography. In another case, it found a previous revert and related issue showing that workspace labels should not appear below team labels. None of these product rules was defined in one obvious place in the code.

18:16

Daily distillation turns corrections into future instructions

Review comments and subsequent code changes create reusable organizational knowledge. Linear runs an automation once a day, or at another frequency based on pull request volume, over the code merged that day. It finds actionable lessons, including comments that led to changes or reverts, extracts the learning, and adds it to agents.md or related documentation. Moor warns that this context cannot grow forever, so teams must experiment with the prompt and manage the resulting instructions. The aim is to avoid making the same correction repeatedly.

"So now we're thinking less about is this code correct and more about is this the right change for the product?"15:33
Who should watch
  • You are building coding-agent workflows and need agents to understand why a change exists, not only where to edit the code.
  • Your team has product decisions, incidents, reverts, or review corrections scattered across issues, pull requests, and internal systems.
  • You want a practical workflow for turning review feedback into context that later agents can use.