Linear Agent can now read your codebase and answer questions from the source itself. It can explain how a feature works, investigate likely causes behind a problem, and help teams understand the current implementation directly.

Learn more on the changelog.

Why Code Intelligence for Linear⁠

As companies grow, coordination gets more expensive. Slack and Teams made questions easy to ask, but answering them still takes time and interrupts the people who hold the context. That context often already exists across code, specs, customer notes, issues, and decisions. The problem has been that the information is hard to reach, and there hasn’t been a system where it could all live together.

Linear is where product work already happens. Problems come in, context accumulates, plans get made, and work moves toward release. We had much of that in place, and we knew one important source of context was still missing, the code itself.

Code is one of the best forms of product context because it is objective. A behaviour either exists or it does not, and a feature either supports a case today or it does not, so you can get a definite answer about the state of things as they exist.

Once we brought code context into the system, we found it had impact beyond coding workflows. Our team made 1,055 Code Intelligence queries in February, 2,681 in March, 4,267 in April, and is on track to clear 5,200 in May. Each query is a question someone might otherwise have asked a teammate or spent time investigating on their own.

Linear can now do code research on demand or automatically across your team.

Bug triage can start with a hypothesis⁠

One of the heaviest lifts for engineers doing triage is debugging against the codebase. The old workflow starts with manual investigation, which means finding the relevant area, checking recent changes, tracing the code paths, and guessing where to look first.

With Code Intelligence, you can ask the agent directly, or you can set it up so every issue is investigated automatically as it comes in.

@Linear why may this have regressed?
Check recent commits in this area, identify the 
most relevant code paths, and give me the most 
likely causes to validate first.

The agent can surface likely regressions, relevant code paths, and recent commits in the area. When that happens automatically as the bug arrives, anyone who picks up the issue starts from a partially investigated state rather than a blank one.

Support questions can start from the source⁠

A customer reports a problem. Say an invite link stopped working, a login flow behaves unexpectedly, or a sync fails.

Normally, that gets escalated to engineering so someone can reconstruct the logic from the codebase. With Code Intelligence, the first investigation can happen immediately.

@Linear why would an invite link stop working after 
reinstalling the app? Check the relevant code paths
and any recent changes that could explain it.

The agent can trace the relevant code paths, inspect recent changes, and explain what is likely happening, so support can start with a grounded answer instead of a vague handoff. The question moves from “can someone look into this?” to “here is what the system appears to be doing, and here is where it is happening,” and escalations only happen when there is an actual problem that needs to be addressed.

The value is speed, better quality at the first point of contact, and more confident escalation of real problems.

Product can understand the system while writing the spec⁠

A PM is researching customer requests across the system to understand the pattern in what users are asking for. The team sees a recurring need and wants to know how large the implementation lift would be against the current codebase.

These are product questions, but they are also code questions.

With Code Intelligence, the team can move from product ideas to scoping the technical lift in the same flow.

@linear based on the user requests, what would be 
the technical lift of implementing this? write your 
findings in to a technical spec as part of this project.

The agent can connect the request pattern to the current implementation, identify the main systems involved, and surface the edge cases that matter before the spec is written. Specs start from a more accurate picture of what is already there, which makes it easier to gauge feasibility and communicate the idea clearly.

Find the people with context⁠

Code can also help answer an organisational question: Who has worked in this area before?

That context is usually scattered across memory, old pull requests, and half-remembered ownership. Code Intelligence can trace the relevant code paths, inspect recent changes, and look at git history to surface the people most likely to have context.

@Linear who has worked on this feature in the past?
Look at the relevant code paths, git history, and 
recent changes and point me to the people most likely 
to have context.

That gives designers and engineers a fast way to find likely context holders through the code itself.

Code context is for more than coding⁠

Code context is useful whenever you are trying to understand what exists today. It is the objective record of the current state.

Outside of coding, it helps support explain how things work without always escalating or trying to investigate alone. It helps product understand implementation before planning changes, helps teams estimate work with better context, and helps engineering by automatically diagnosing incoming problems.

That is what Code Intelligence adds to Linear Agent. It brings the source of truth for how the product actually works into the same place where teams already triage problems, gather feedback, plan work, and make decisions.

Code Intelligence is now available in public beta for Business and Enterprise plans, and free to use during the beta period. See the changelog for more details.