# Linear

Updates from the Linear team.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Introducing Mobile Diffs

DevFeed: [Introducing Mobile Diffs](<https://devfeed.tech/articles/introducing-mobile-diffs-121226.md>)

Original publisher: [Read original article](<https://linear.app/now/mobile-diffs>)

Published: 2026-11-05T16:44:00Z

Content type: release

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [Code review](<https://devfeed.tech/topics/code-review.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [Linear](<https://devfeed.tech/topics/linear.md>), [Android](<https://devfeed.tech/topics/android.md>), [iOS](<https://devfeed.tech/topics/ios.md>), [codex](<https://devfeed.tech/topics/codex.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [android](<https://devfeed.tech/tags/android.md>), [app](<https://devfeed.tech/tags/app.md>), [changes](<https://devfeed.tech/tags/changes.md>), [code](<https://devfeed.tech/tags/code.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [codex](<https://devfeed.tech/tags/codex.md>), [coding](<https://devfeed.tech/tags/coding.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [comment](<https://devfeed.tech/tags/comment.md>), [diffs](<https://devfeed.tech/tags/diffs.md>), [ios](<https://devfeed.tech/tags/ios.md>), [linear](<https://devfeed.tech/tags/linear.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [phone](<https://devfeed.tech/tags/phone.md>), [review](<https://devfeed.tech/tags/review.md>), [send](<https://devfeed.tech/tags/send.md>), [threads](<https://devfeed.tech/tags/threads.md>), [work](<https://devfeed.tech/tags/work.md>)

### AI overview

Linear Diffs is available on iOS and Android, letting users review pull requests and continue review work from a phone. Guided Reviews divide a PR into sections that explain what changed and why; users can comment, reply to teammates' or agents' review threads, and send fixes back to an agent. Review requests, approvals, and comments appear in the home screen and Linear Inbox, preview links open on the device, and files marked viewed sync between phone and desktop. To use it, install the latest Linear app; workspaces not yet using Diffs need an admin to upgrade the GitHub integration for code access.

### Source excerpt

Diffs, Linear's fast and focused code review, is now on iOS and Android. Approve changes, reply to threads, and send work back to agents from your phone.

## Five principles for working with Loops

DevFeed: [Five principles for working with Loops](<https://devfeed.tech/articles/five-principles-for-working-with-loops-86262.md>)

Original publisher: [Read original article](<https://linear.app/now/five-principles-working-with-loops>)

Published: 2026-10-13T08:06:00Z

Content type: tutorial

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [Agent Skills](<https://devfeed.tech/topics/agent-skills.md>), [Slack](<https://devfeed.tech/topics/slack.md>), [Linear](<https://devfeed.tech/topics/linear.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [automation](<https://devfeed.tech/tags/automation.md>), [code](<https://devfeed.tech/tags/code.md>), [code-analysis](<https://devfeed.tech/tags/code-analysis.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

An engineer building Linear Loops shares five practices for delegating recurring work to agents: identify suitable tasks, start with a narrow scope, use available workspace context, refine loops with the agent, and keep the team informed. Examples include security vulnerability triage, deprecated-code cleanup, bug investigation, and meeting preparation.

### Source excerpt

How to turn recurring tasks into shared, reliable workflows.

## AI coding has made CI a bottleneck, so we reworked ours to keep up

DevFeed: [AI coding has made CI a bottleneck, so we reworked ours to keep up](<https://devfeed.tech/articles/ai-coding-has-made-ci-a-bottleneck-so-we-reworked-ours-to-keep-up-83534.md>)

Original publisher: [Read original article](<https://linear.app/now/ci-bottleneck-reworked>)

Published: 2026-09-21T12:26:00Z

Content type: article

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [ci](<https://devfeed.tech/tags/ci.md>), [costs](<https://devfeed.tech/tags/costs.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [tests](<https://devfeed.tech/tags/tests.md>), [time](<https://devfeed.tech/tags/time.md>)

### AI overview

Linear describes how it reworked CI as AI-assisted coding increased software delivery speed. The changes included faster runners and tooling, shorter critical-path jobs, less repeated setup, and more efficient test execution. The team reports reducing pull request wait times and runner costs despite a much larger test suite.

### Source excerpt

We cut PR wait time and running costs by rethinking CI as a system, from the infrastructure underneath it to how work gets scheduled and tests get parallelized.

## Styling Linear for the future with StyleX

DevFeed: [Styling Linear for the future with StyleX](<https://devfeed.tech/articles/styling-linear-for-the-future-with-stylex-83583.md>)

Original publisher: [Read original article](<https://linear.app/now/styling-linear-for-the-future-stylex>)

Published: 2026-08-26T22:47:00Z

Content type: article

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [styled-components](<https://devfeed.tech/topics/styled-components.md>), [Loop Engineering](<https://devfeed.tech/topics/loop-engineering.md>), [interactive web design](<https://devfeed.tech/topics/interactive-web-design.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [automation](<https://devfeed.tech/tags/automation.md>), [migration](<https://devfeed.tech/tags/migration.md>), [stylex](<https://devfeed.tech/tags/stylex.md>), [styling](<https://devfeed.tech/tags/styling.md>), [tooling](<https://devfeed.tech/tags/tooling.md>)

### AI overview

Linear describes migrating its React applications from styled-components to StyleX across more than 1,000 pull requests. The team combined a deterministic codemod, agents, human review, and custom linting and repository checks to manage edge cases and keep product work moving. The migration reduced runtime style injection; on view-heavy pages, the team measured roughly 20-35% less main-thread CPU work related to style generation and injection, with results varying by page and machine.

### Source excerpt

A long-running migration that became an exercise in tooling, automation, and designing clearer boundaries for both humans and agents.

## Sharing Linear's growth with the people building it

DevFeed: [Sharing Linear's growth with the people building it](<https://devfeed.tech/articles/sharing-linear-s-growth-with-the-people-building-it-83580.md>)

Original publisher: [Read original article](<https://linear.app/now/sharing-growth-with-the-people-building-linear>)

Published: 2026-08-26T11:43:06Z

Content type: article

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [Linear](<https://devfeed.tech/topics/linear.md>), [engineering-leadership](<https://devfeed.tech/topics/engineering-leadership.md>)

Tags: [accel](<https://devfeed.tech/tags/accel.md>), [accelerated](<https://devfeed.tech/tags/accelerated.md>), [adopting](<https://devfeed.tech/tags/adopting.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [cursor](<https://devfeed.tech/tags/cursor.md>), [growth](<https://devfeed.tech/tags/growth.md>), [hiring](<https://devfeed.tech/tags/hiring.md>), [issue-tracking](<https://devfeed.tech/tags/issue-tracking.md>)

### AI overview

Linear describes a $99 million tender offer that let current and former employees sell some vested equity at a $2.5 billion valuation. The company says it is cashflow positive, has passed $100 million in annual recurring revenue, and is expanding its agent platform for product development. It reports that agents are installed in 95% of paid workspaces and generate half of newly created work, while sharing plans to hire across several functions.

### Source excerpt

As Linear passes $100 million in ARR, we're giving our team another opportunity to participate in the upside.

## Rebuilding Linear's delta sync read path

DevFeed: [Rebuilding Linear's delta sync read path](<https://devfeed.tech/articles/rebuilding-linear-s-delta-sync-read-path-83573.md>)

Original publisher: [Read original article](<https://linear.app/now/rebuilding-delta-sync-read-path>)

Published: 2026-08-18T12:42:00Z

Content type: article

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [database-optimization](<https://devfeed.tech/topics/database-optimization.md>), [sync-generators](<https://devfeed.tech/topics/sync-generators.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [change-data-capture](<https://devfeed.tech/tags/change-data-capture.md>), [database](<https://devfeed.tech/tags/database.md>), [deduplication](<https://devfeed.tech/tags/deduplication.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [latency](<https://devfeed.tech/tags/latency.md>), [sync](<https://devfeed.tech/tags/sync.md>)

### AI overview

Linear describes redesigning its delta-sync read path for a local-first application. It moved filtering of large sync-action sets from a Postgres read path to turbopuffer posting-list indexes, while keeping Postgres authoritative and fetching full payloads only after filtering. The design uses a change-data-capture pipeline, late enrichment, overlap and deduplication to handle replication lag, and a fallback to Postgres. Linear reports flatter p95 and p99 latency as workspaces grow.

### Source excerpt

How we use Turbopuffer to keep catch-up latency predictable across more than 20 TB of sync actions.

## How we built Linear Agent

DevFeed: [How we built Linear Agent](<https://devfeed.tech/articles/how-we-built-linear-agent-83549.md>)

Original publisher: [Read original article](<https://linear.app/now/how-we-built-linear-agent>)

Published: 2026-08-10T12:19:00Z

Content type: article

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [Linear](<https://devfeed.tech/topics/linear.md>), [agent orchestration](<https://devfeed.tech/topics/agent-orchestration.md>), [Agent Skills](<https://devfeed.tech/topics/agent-skills.md>), [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [human in the loop agent](<https://devfeed.tech/topics/human-in-the-loop-agent.md>), [agent to agent communication](<https://devfeed.tech/topics/agent-to-agent-communication.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-tools](<https://devfeed.tech/tags/agent-tools.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [cli](<https://devfeed.tech/tags/cli.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [linear](<https://devfeed.tech/tags/linear.md>)

### AI overview

Linear explains how it built Linear Agent to handle complex product tasks while limiting unpredictable behavior. The design uses focused system prompts, constrained tools, product-specific skills loaded as needed, contextual approval checks, and a custom harness for streaming, durable workflows, and asynchronous sub-agent execution. The team chose a narrower action surface to improve predictability and reduce mistakes, while retaining flexibility as models improve.

### Source excerpt

The product and engineering decisions we made so Linear Agent can handle complex tasks without becoming unpredictable.

## Introducing Loops

DevFeed: [Introducing Loops](<https://devfeed.tech/articles/introducing-loops-83558.md>)

Original publisher: [Read original article](<https://linear.app/now/introducing-loops>)

Published: 2026-07-20T15:30:00Z

Content type: release

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [Loop Engineering](<https://devfeed.tech/topics/loop-engineering.md>), [Linear](<https://devfeed.tech/topics/linear.md>), [Product Management](<https://devfeed.tech/topics/product-management.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [developer-workflows](<https://devfeed.tech/tags/developer-workflows.md>), [linear](<https://devfeed.tech/tags/linear.md>), [loop-engineering](<https://devfeed.tech/tags/loop-engineering.md>), [mcp-servers](<https://devfeed.tech/tags/mcp-servers.md>), [product-development](<https://devfeed.tech/tags/product-development.md>)

### AI overview

Linear is launching Loops, recurring AI workflows that run on a schedule or in response to events across a team's workspace. Teams can use them to triage bug reports, create follow-up issues, and update project plans, with shared visibility into each run.

### Source excerpt

Loop engineering has quickly emerged as an important practice in software development. In tools like Claude Code and Codex, developers define recurring or trigger-based behavior for their agents, usually through a /loop command, and hand off the repetitive tasks that would otherwise consume their attention. The resulting productivity gains are real, but so far they have mostly been limited to individual developer workflows. What if an entire product team could work this way? The opportunity is everywhere. Product development is full of repetitive operational work that requires a human in the loop: an engineer needs to understand every incoming bug report and investigate a project manager needs to notify teams affected by scope changes as they happen a marketer needs to update the launch schedule as target dates shift These processes are usually well understood, but someone still has to monitor incoming changes, apply judgement, and take action. That's why today we're launching Loops, a new way for Linear Agent to take on recurring work across your team. Loops let you define scheduled or event-driven operations for Linear Agent to run across your workspace. Because they operate natively inside Linear, they can work from the full context of your issues, projects, documents, and connected tools, while remaining visible and controllable by your teams. The result is a practical way to offload product operations and keep important work moving without constant oversight. How Loops work To set up a Loop, describe the job in plain language and then choose whether it should run on a schedule or in response to an event. Each time a loop runs, Linear Agent reviews its instructions and determines what should happen next. It can draw on context from Linear, connected codebases, MCP servers, and previous runs. Because Loops are fully AI-powered, they can apply judgment as they work. They can account for exceptions, navigate ambiguity, gather missing information, and decide on the

## Teaching an agent to auto-fix bugs

DevFeed: [Teaching an agent to auto-fix bugs](<https://devfeed.tech/articles/teaching-an-agent-to-auto-fix-bugs-83561.md>)

Original publisher: [Read original article](<https://linear.app/now/linear-agent-bug-fix>)

Published: 2026-06-12T16:34:00Z

Content type: article

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [Linear](<https://devfeed.tech/topics/linear.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [bugfixes](<https://devfeed.tech/topics/bugfixes.md>), [workflow automation](<https://devfeed.tech/topics/workflow-automation.md>), [ai code review](<https://devfeed.tech/topics/ai-code-review.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [automation](<https://devfeed.tech/tags/automation.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [datadog](<https://devfeed.tech/tags/datadog.md>), [linear](<https://devfeed.tech/tags/linear.md>), [tasks](<https://devfeed.tech/tags/tasks.md>), [triage](<https://devfeed.tech/tags/triage.md>), [types](<https://devfeed.tech/tags/types.md>)

### AI overview

A Linear engineer describes automating bug triage with Linear Agent. The agent handles well-scoped dead feature flag cleanup reliably, while fixes for variable background task failures succeed less often; added gates reduce unsuitable pull requests, and the agent can still investigate issues it cannot fix. The article emphasizes providing task context through workflow skills, automation rules, code conventions, and review.

### Source excerpt

I was very skeptical of AI to begin with. Part of me suspected the technology wasn't as capable as the hype would suggest, while another part was deeply worried that it was far more capable than I wanted to admit. But the closer I got to the technology the more those worries started to fade. The tech is very capable, but when you work with it you start to realise the extent of that capability. Where it's strong, where it's weak, and how the engineering role is evolving to fit the spaces between them. I've spent the majority of my time over the past few months building out automations in Linear. When combined with the Linear Agent, which can read and write code, and take actions in your workspace, you get an outcome that's close to what we described last year as "Self-driving SaaS". Software that can do things in the background on your behalf, moving work forward, guided by rules and gates rather than a human hand. How much it can own from start to finish varies enormously depending on how your team works and what your codebase looks like, it's not a fixed property of the technology. We've had to experiment a lot to find the edges of that capability and then work back. An automation I've been experimenting with lately is getting the Linear Agent to auto-fix bugs that land in triage. When we first tried this workflow we had the agent attempt a first pass at all the bugs coming in. That didn't work very well because there wasn't enough context to one-shot the fix, so we had to narrow the ask and feed it the right instructions and tools. There are two types of issues that the agent is good at fixing on the first pass in our workspace today: catching dead feature flags and patching up failing background tasks. Automations I've been building Through our Datadog integration, a monitor catches the problem and files an issue into triage, where an automation assigns it to the Linear Agent to pick up, run the relevant skill, and take a pass. Dead feature flags are the cleaner

## Linear launches coding sessions, automated triage, and code review for Linear Agent

DevFeed: [Linear launches coding sessions, automated triage, and code review for Linear Agent](<https://devfeed.tech/articles/now-linear-writes-the-code-too-83537.md>)

Original publisher: [Read original article](<https://linear.app/now/coding-sessions-for-linear-agent>)

Published: 2026-06-11T18:25:29Z

Content type: release

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Linear](<https://devfeed.tech/topics/linear.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [Code review](<https://devfeed.tech/topics/code-review.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [linear](<https://devfeed.tech/tags/linear.md>), [product](<https://devfeed.tech/tags/product.md>), [pull-request](<https://devfeed.tech/tags/pull-request.md>), [review](<https://devfeed.tech/tags/review.md>)

### AI overview

Linear Agent adds coding sessions that let it take an issue through investigation, implementation, and pull request creation in a shared cloud workflow. Automated triage can start that process when issues arrive, while Diffs supports code review in Linear. Teams can supply context, redirect the agent, and choose how much of the process to automate.

### Source excerpt

Agents are becoming capable of doing more of the work involved in building software, but they're still mostly individual productivity tools, useful to one person at a time. Building a product is something a team does together, and the work that goes into it, like the decisions and the reasoning behind them, forms the context the whole product is built on. That context rarely lives in one place. It accumulates across Linear issues, documents, Slack threads, and code, which is why we've worked to bring more of product development into Linear and pull it all together. Linear Agent can draw on all of it. We've given it skills and automations so it follows how your team works, and MCP to reach the rest of your stack. It can read your codebase with Code Intelligence and help you review code changes with Diffs. But the loop wasn't complete. The coding work itself still happened somewhere else, so an engineer had to take the context from Linear, restate it inside another tool, monitor the work, and bring the result back for review. Today, we're launching coding sessions, automated triage, and Diffs to bring execution into the same shared system. Coding sessions Coding sessions let Linear Agent natively move directly from an issue to implementation. You can delegate an issue to the agent, ask it to fix something, or @mention it from Slack or Teams. The agent reads the issue and its surrounding discussion, investigates the codebase, proposes an approach, writes the code, and opens a pull request. This all happens in the cloud, using frontier models and harnesses like Claude Code or Codex. The coding session starts with the context already connected to the issue: the original request, customer signal, product decisions, related work, and discussion. Nobody needs to gather this information and reconstruct it inside a new prompt. The session is also shared with the team. Anyone can follow the work, contribute context, redirect the approach, request changes, or take over. The ses

## Reviewing code in the agent era

DevFeed: [Reviewing code in the agent era](<https://devfeed.tech/articles/reviewing-code-in-the-agent-era-83575.md>)

Original publisher: [Read original article](<https://linear.app/now/reviewing-code-in-the-agent-era>)

Published: 2026-06-10T14:16:00Z

Content type: article

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [Code review](<https://devfeed.tech/topics/code-review.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [linear](<https://devfeed.tech/tags/linear.md>), [quality](<https://devfeed.tech/tags/quality.md>), [review](<https://devfeed.tech/tags/review.md>)

### AI overview

A Linear engineer describes how increased code volume from AI agents has changed code review. Linear Diffs helps organize reviews, while reviewers focus on understanding the change's purpose, evaluating product impact and edge cases, and discussing feedback with teammates. The author says this keeps quality centered on whether code is useful as well as correct.

### Source excerpt

Like a lot of people who build software, I felt the ground shift at the start of 2026. The models got better, the agents got better with them, and almost overnight the amount of code moving through my team went up. Between January and March our total issues created and PRs merged both climbed by 50%. That was exciting, and it was also a problem. With that much code moving, I felt the pull to "looks good!" my way through reviews just to keep the queue down, and that sat badly with me, because quality is something we genuinely obsess over at Linear. I kept landing on the same question, which was how I could stay on top of this much review without lowering my bar. That question is really why we leaned so hard into building Linear Diffs this year. After several months of living in it, I can say it has helped me tame the deluge of agentic code, and here is how I use it day to day. Reviews now have a prominent space in Linear, so I can easily stay on top of what I need to review for others and my own work that's getting reviewed. I rely on Linear's notifications system, both via the inbox in the app and through the Slack integration, so I don't miss when new requests come in or when I get new feedback. When I pick up a review request, the first thing I do is get my bearings. I want to understand why we're making a change in the first place. With Reviews in Linear, I'm only one click away from seeing what inspired the code, like a piece of customer feedback, a bug report, or an idea someone shared on a Slack thread. If the change is something you can see, like a UI tweak or a new flow, I'll open the preview build first to feel how it behaves. I take screenshots and screen recordings to flag anything that looks or feels off, so the author sees exactly what I'm reacting to. Then I move to the diff itself. I scroll through once to get a sense of the size, patterns, scope. If the change is sizable, I then switch into a guided review. Linear groups the change into chunks that r

## Code review should be fast

DevFeed: [Code review should be fast](<https://devfeed.tech/articles/code-review-should-be-fast-83536.md>)

Original publisher: [Read original article](<https://linear.app/now/code-review-should-be-fast>)

Published: 2026-05-28T07:00:00Z

Content type: release

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [issue tracking](<https://devfeed.tech/topics/issue-tracking.md>), [ai code review](<https://devfeed.tech/topics/ai-code-review.md>)

Tags: [building-software](<https://devfeed.tech/tags/building-software.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [pull-requests](<https://devfeed.tech/tags/pull-requests.md>)

### AI overview

Linear announces Diffs, a pull request review feature that places reviews alongside related issues, projects, and customer context. It organizes large diffs into guided chapters, separates formatting changes from substantive edits, and surfaces review priority. Linear says the feature is available on all plans.

### Source excerpt

Why we built Diffs When we started Linear, we set out to improve the experience of building software, which had been full of friction for too long. We obsessed over making the core workflow feel fast, fluid, and enjoyable to use. Code review has stayed painfully slow while everything else sped up. Growing PR volumes from coding agents are putting further strain on an already creaking process. So much so that the speed gained from using agents gets swallowed in review. Diffs is designed to keep code review fast without sacrificing the rigour of the work. We approached Diffs with a short list of beliefs about what review should be: Fast. Reviews should open near-instantly Focused. Reviews should show what matters and strip out the noise In context. Code should sit next to the issue, project, and customer signal behind the change To begin with, we've focused where the friction was loudest. Knowing what to review first Review requests get buried in your email inbox and the queue offers no guidance on what is urgent, because every PR in the list looks roughly the same. The requester shouldn't have to spam your Slack DMs to get your attention. Reviews sit inside Linear next to the rest of your work, where priority is visible because everything else competing for your attention is right there too. Each Diff is attached to the issue and project that produced it, so you can see when one is blocking something critical and weigh it against what else is on your plate. Getting through a huge diff Large pull requests are usually reviewed in whatever order the filesystem produced the files, with formatting churn and refactoring noise mixed into the substantive edits. Reviewer attention runs out before the diff does, and the rest gets either skimmed or rubber-stamped. Stacked diffs emerged as a workaround, but it's a lot of overhead to compensate for tools that can't handle a large diff. Guided reviews in Linear break the diff into chapters that follow the order the work was reason

## Code Intelligence for Linear Agent

DevFeed: [Code Intelligence for Linear Agent](<https://devfeed.tech/articles/code-intelligence-for-linear-agent-83535.md>)

Original publisher: [Read original article](<https://linear.app/now/code-intelligence-for-linear-agent>)

Published: 2026-05-14T18:50:00Z

Content type: release

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [Linear](<https://devfeed.tech/topics/linear.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [ai code review](<https://devfeed.tech/topics/ai-code-review.md>)

Tags: [code-intelligence](<https://devfeed.tech/tags/code-intelligence.md>), [feature](<https://devfeed.tech/tags/feature.md>), [linear](<https://devfeed.tech/tags/linear.md>), [product](<https://devfeed.tech/tags/product.md>), [workflow](<https://devfeed.tech/tags/workflow.md>)

### AI overview

Linear Agent's Code Intelligence feature can inspect a codebase to answer questions, investigate likely causes of problems, and help teams understand existing implementation. The article describes uses in bug triage, customer support, product scoping, and finding people with relevant code history. The feature is available in public beta for Business and Enterprise plans.

### Source excerpt

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. 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 rathe

## How we hire at Linear

DevFeed: [How we hire at Linear](<https://devfeed.tech/articles/how-we-hire-at-linear-83553.md>)

Original publisher: [Read original article](<https://linear.app/now/how-we-hire-at-linear>)

Published: 2026-04-28T12:22:00Z

Content type: article

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [engineering-culture](<https://devfeed.tech/topics/engineering-culture.md>)

Tags: [hiring](<https://devfeed.tech/tags/hiring.md>), [interviews](<https://devfeed.tech/tags/interviews.md>), [ownership](<https://devfeed.tech/tags/ownership.md>)

### AI overview

Linear explains its hiring criteria and process, emphasizing craft, judgment, ownership, and clear communication. Candidates undergo focused interviews and a paid two-to-five-day work trial. The article also describes hiring decisions, compensation transparency, and the autonomy expected within small product teams.

### Source excerpt

Our perspective on hiring Hiring well matters more than hiring fast. We're happy to take our time, and believe each person who joins the team should raise the bar for the next one. We value slope over credentials. Someone growing fast and thinking clearly will often outperform someone with more years and logos on their resume. The best talker in the room isn't always the best doer. Interviews favor people who present well under pressure, not necessarily people who are capable of great work. It's one reason work trials are part of the process here. They give both sides better signal than another round of curated conversations. We're a remote team, distributed across time zones with relatively little process overhead. That's by design, because we think the best builders want clear ownership and a lot of room to do the most meaningful work of their careers. What we look for The specifics vary by role, but the strongest candidates at Linear tend to share a few attributes: Craft. You care about doing work well and have built real depth in your domain. You notice details that matter. You know the difference between extra effort and meaningful quality. This shows up differently depending on the role, but you can usually tell when someone has it. Judgment. You can reason through tradeoffs, work with incomplete information, and make sound decisions without waiting for a script. At Linear we don't use OKRs or run A/B tests. Decisions get made with taste, customer insight, and direct judgment. In interviews, we're listening for how you think through a real problem rather than how polished the answer sounds. Ownership. You take responsibility for a problem from beginning to end. At Linear, teams are small. You shape direction, make decisions, talk to users when needed, and communicate progress. It's a full-stack way of working, and it requires someone who doesn't need a lot of process to stay oriented. Clarity. You can explain your thinking simply and directly. You respect othe

## Output isn't design

DevFeed: [Output isn't design](<https://devfeed.tech/articles/output-isn-t-design-83569.md>)

Original publisher: [Read original article](<https://linear.app/now/output-isn-t-design>)

Published: 2026-04-17T14:23:00Z

Content type: opinion

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [User interface design](<https://devfeed.tech/topics/ui-design.md>), [AI-enhanced product development](<https://devfeed.tech/topics/ai-enhanced-product-development.md>), [AI in frontend development](<https://devfeed.tech/topics/ai-in-frontend-development.md>), [human centric design](<https://devfeed.tech/topics/human-centric-design.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [design](<https://devfeed.tech/tags/design.md>), [designing](<https://devfeed.tech/tags/designing.md>), [product](<https://devfeed.tech/tags/product.md>)

### AI overview

The article argues that design is the work of understanding a problem and fitting a form to its context, not simply producing interfaces or code. AI tools can quickly generate plausible outputs and help with prototyping, but they do not replace the judgment, exploration, and time needed to resolve user needs, technical constraints, and other requirements.

### Source excerpt

Design keeps being misunderstood in our industry. New tools keep promising to generate interfaces faster, move words to product instantly, or collapse design directly into code. The assumption behind them is clear: that design is the act of producing. That is the misunderstanding. The hard part of design is rarely generating the form. It is understanding the problem well enough to know what and how something should exist at all. There is use and place for these tools, but tools are not the design process. Christopher Alexander came closer than anyone to naming this clearly. In Notes on the Synthesis of Form, he describes design as the search for a good fit between a form and its context. Context, in his sense, is not a background condition. It is the full set of forces that make a problem what it is: human needs, technical constraints, conflicting requirements, habits, edge cases, and relationships that are easy to miss until you spend time with them. Bad design appears where those forces remain unresolved. Good design appears where those misfits have been worked through carefully. That distinction matters even more now because of how AI encourages you to work. They generate plausible outputs quickly, but they do not necessarily help you understand the underlying problem. In practice, they often do the opposite. They generate outputs, instead first trying to shape the problem or the form to the real conditions of the problem. You can already see the result in products that look polished, ambitious, and impressive at first glance, but begin to unravel the moment you actually use them. They feel brittle, poorly integrated, and full of decisions that were never fully worked through. The form is there. The fit is not. That is also why I still prefer designing visually over prompting. Working visually keeps me close to the problem and is slow enough gives me time to think while I work. Moving things around, testing relationships, and refining structure is not separate fr

## How we use Linear Agent at Linear

DevFeed: [How we use Linear Agent at Linear](<https://devfeed.tech/articles/how-we-use-linear-agent-at-linear-83557.md>)

Original publisher: [Read original article](<https://linear.app/now/how-we-use-linear-agent-at-linear>)

Published: 2026-04-10T12:17:56Z

Content type: article

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [Linear](<https://devfeed.tech/topics/linear.md>), [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Product Management](<https://devfeed.tech/topics/product-management.md>), [agent orchestration](<https://devfeed.tech/topics/agent-orchestration.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [linear](<https://devfeed.tech/tags/linear.md>), [product](<https://devfeed.tech/tags/product.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

Linear describes three internal workflows using its agent across customer experience, product management, and engineering: turning customer feedback into issues and shipped features, converting Slack discussions into pull requests, and letting a product manager use an agent to make a small product change. The examples include routing and grouping requests, investigating codebase context, delegating coding work, and human review. The article says teams should introduce autonomy gradually and break work into small, focused steps.

### Source excerpt

The workflows that proved most useful across CX, Product, and Engineering, and what they tell us about working with agents.

## Post mortem on Linear security incident on March 24th, 2026

DevFeed: [Post mortem on Linear security incident on March 24th, 2026](<https://devfeed.tech/articles/post-mortem-on-linear-security-incident-on-march-24th-2026-83563.md>)

Original publisher: [Read original article](<https://linear.app/now/linear-incident-on-mar-24th-2026>)

Published: 2026-04-06T15:35:15Z

Content type: article

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [Access Control](<https://devfeed.tech/topics/access-control.md>), [Post Mortem](<https://devfeed.tech/topics/post-mortem.md>), [Security](<https://devfeed.tech/topics/security.md>)

Tags: [access-control](<https://devfeed.tech/tags/access-control.md>), [agent](<https://devfeed.tech/tags/agent.md>), [api-keys](<https://devfeed.tech/tags/api-keys.md>), [audit](<https://devfeed.tech/tags/audit.md>), [authentication](<https://devfeed.tech/tags/authentication.md>), [bug](<https://devfeed.tech/tags/bug.md>), [incident](<https://devfeed.tech/tags/incident.md>), [linear](<https://devfeed.tech/tags/linear.md>), [post-mortem](<https://devfeed.tech/tags/post-mortem.md>), [security](<https://devfeed.tech/tags/security.md>), [security-incident](<https://devfeed.tech/tags/security-incident.md>)

### AI overview

A Linear code change caused team-level permission filters to be skipped for about an hour, potentially exposing private-team data to other members within affected workspaces. The postmortem describes the variable shadowing bug, the test coverage gap, the exposure paths, remediation, and planned improvements to authorization testing and monitoring.

### Source excerpt

A code change temporarily weakened team-level permissions within some workspaces from 12:07 to 1:10 UTC (about one hour) due to a bug that caused a permission filter to be skipped.

## A calmer interface for a product in motion

DevFeed: [A calmer interface for a product in motion](<https://devfeed.tech/articles/a-calmer-interface-for-a-product-in-motion-83530.md>)

Original publisher: [Read original article](<https://linear.app/now/behind-the-latest-design-refresh>)

Published: 2026-03-12T14:18:00Z

Content type: article

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [User interface design](<https://devfeed.tech/topics/ui-design.md>), [designer developer handoff](<https://devfeed.tech/topics/designer-developer-handoff.md>), [Dark Mode](<https://devfeed.tech/topics/dark-mode.md>), [Product Management](<https://devfeed.tech/topics/product-management.md>), [Docker AI Governance](<https://devfeed.tech/topics/docker-ai-governance.md>)

Tags: [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [codex](<https://devfeed.tech/tags/codex.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [cursor](<https://devfeed.tech/tags/cursor.md>), [design](<https://devfeed.tech/tags/design.md>), [design-principles](<https://devfeed.tech/tags/design-principles.md>), [design-system](<https://devfeed.tech/tags/design-system.md>), [feature-flags](<https://devfeed.tech/tags/feature-flags.md>)

### AI overview

Linear describes a visual refresh focused on making its dense interface calmer and more consistent, with changes to navigation, tabs, icons, borders, and default color palettes. The team used feature flags, an in-app color tool built with Claude Code, and coding agents to compare designs, explore alternatives, and integrate changes incrementally.

### Source excerpt

The thinking, trade-offs, and tools behind our design refresh

## Design is more than code

DevFeed: [Design is more than code](<https://devfeed.tech/articles/design-is-more-than-code-83544.md>)

Original publisher: [Read original article](<https://linear.app/now/design-is-more-than-code>)

Published: 2025-12-19T19:30:00Z

Content type: opinion

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [UI/UX Design](<https://devfeed.tech/topics/ui-ux-design.md>), [engineering-leadership](<https://devfeed.tech/topics/engineering-leadership.md>), [AI in frontend development](<https://devfeed.tech/topics/ai-in-frontend-development.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [design](<https://devfeed.tech/tags/design.md>), [engineering](<https://devfeed.tech/tags/engineering.md>)

### AI overview

The author argues that software design should begin by understanding the problem and exploring concepts before moving into execution. Code can help test a chosen direction, but making production implementation the default risks valuing output over intent and weakening the design process. AI tools raise related questions about designers' and engineers' roles.

### Source excerpt

Designing with code is a recurring discussion, and it's flared up again. I've written about it twice now. Design as a search, not a pipeline. How tools carry opinions, and how those opinions shape what feels "reasonable" to attempt. Why constraints that arrive too early can close off possibilities before you've had a chance to find them. I'm skeptical of the industry's drive toward grand unification, collapsing a nuanced process into code and calling it progress. The recent discourse has focused on whether designers should code, whether code is the right medium for design, how code "presents the truth" of a design, and so on. But I think centering this debate on code and tools is reductive. The bigger question to me is what happens to how we see designers contributing in the future, especially now with AI and these new tools. How do roles evolve, and what do we start expecting from each of them? Are designers now engineers, with the same expectations? Do engineers start having the same expectations of designers? Will we still have a "head of engineering" and "head of design", or does it turn into something like "head of craft"? Titles don't matter that much, but these questions are useful because they reveal what we value and how we think the job gets done. And then the practical question. If designers get funneled toward engineering, designing with code directly, is that a good direction? What do we lose or gain? Part of why this discussion gets messy is that design means different things to different people. Your view on it depends on what kind of design you do, and how you understand design as a practice. I believe design comes in many flavors. It's influenced by the person, the domain, the market, the customers. In consumer products, you might need to test ideas quickly because motivations are hard to predict. In B2B or enterprise, you often have more context and can design from that. Some industries require extreme reliability and clarity. The environment matte

## How our Customer Experience team works in Linear

DevFeed: [How our Customer Experience team works in Linear](<https://devfeed.tech/articles/how-our-customer-experience-team-works-in-linear-83540.md>)

Original publisher: [Read original article](<https://linear.app/now/cx-in-linear>)

Published: 2025-11-06T15:43:19Z

Content type: article

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [Linear](<https://devfeed.tech/topics/linear.md>), [issue tracking](<https://devfeed.tech/topics/issue-tracking.md>), [engineering-leadership](<https://devfeed.tech/topics/engineering-leadership.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [Slack](<https://devfeed.tech/topics/slack.md>)

Tags: [customer-experience](<https://devfeed.tech/tags/customer-experience.md>), [customers](<https://devfeed.tech/tags/customers.md>), [github](<https://devfeed.tech/tags/github.md>), [intercom](<https://devfeed.tech/tags/intercom.md>), [product-development](<https://devfeed.tech/tags/product-development.md>), [slack](<https://devfeed.tech/tags/slack.md>)

### AI overview

Linear describes how its Customer Experience team turns customer feedback from support channels into engineering and product work. Integrations and templates route bugs and feature requests into triage, where rotating team members assign or categorize issues. Engineers resolve bugs or implement features, and integrations update the original customer conversation after a fix is merged.

### Source excerpt

One of our main goals in Customer Experience (CX) at Linear is to make the support process feel like an extension of the product itself. That starts with meeting customers where they are--places like Intercom, Slack, Slack Community, X, or Reddit--and turning those conversations into part of our product development process. This creates a tight feedback loop between customers and our EPD teams, leading to a better product and moments of delight when users see their feedback realized in the app. At a high level, this is our process: Stage 1: CX routes customer feedback through designated waypoints (namely Intercom and Slack) into triage queues in Linear monitored by our engineering and product teams. Stage 2: When an issue lands in triage, it triggers a notification to a Linear team member whose priority that week is to take on the work themselves or assign it to the right engineer (in the case of bugs) or attach it to the right candidate projects (in the case of feature requests). Stage 3: The assigned engineer builds the solution and merges the PR. Stage 4: Once the PR is merged, Linear's GitHub integration marks the issue as Done in the Linear issue, which prompts CX to close the loop with the customer. The key is building systems that collect and funnel information in a consistent way, and wiring them together so that handoffs between stages happen efficiently. Here's more detail on how it all works. Stage 1: Intake We initiate the CX process in two main places: Intercom and Slack. There we begin the process of translating a customer's words into a Linear issue. Intercom We use Intercom to collect all support tickets that come in via email or from within the Linear app. We use the Linear-Intercom integration to create Linear issues directly from inside Intercom. (Linear also supports integrations with Zendesk, Salesforce Service Cloud, and Front. Plain and HelpScout have built their own Linear integrations.) We have two templates in Intercom for turning customer fe

## Continuous planning in Linear

DevFeed: [Continuous planning in Linear](<https://devfeed.tech/articles/continuous-planning-in-linear-83539.md>)

Original publisher: [Read original article](<https://linear.app/now/continuous-planning-in-linear>)

Published: 2025-10-30T15:24:26Z

Content type: article

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [Product Management](<https://devfeed.tech/topics/product-management.md>), [task management](<https://devfeed.tech/topics/task-management.md>), [iteration](<https://devfeed.tech/topics/iteration.md>)

Tags: [backlog](<https://devfeed.tech/tags/backlog.md>), [discovery](<https://devfeed.tech/tags/discovery.md>), [leadership](<https://devfeed.tech/tags/leadership.md>), [linear](<https://devfeed.tech/tags/linear.md>), [product](<https://devfeed.tech/tags/product.md>)

### AI overview

Linear describes continuous planning as a way to collect product ideas and customer feedback into candidate projects as they emerge, then prioritize those projects against customer impact and company goals. The projects carry through discovery, planning, and execution, helping teams avoid starting each planning cycle from a blank page.

### Source excerpt

Product planning is a fresh start for your product team. It should feel energizing and full of possibility. After all, it's a rare opportunity to step back from the churn of daily activity and recalibrate your efforts in the most meaningful directions. But in practice, it often creates a kind of whiplash when you shift abruptly from deep execution to high-level strategizing. Gathered in a room, staring at a blank page, it's natural to wonder: Now what do we do? An obvious place to turn is all the customer notes you've collected over the past quarter. But typically those are scattered across different surfaces and recorded at wildly different levels of abstraction: some customer requests are extremely specific--a small feature tweak--while others are sweeping statements about product direction. It's hard to assemble mismatched building blocks into a coherent plan. Our answer to these pitfalls is a process called continuous planning. It's how the product team at Linear plans, and it's a workflow we've designed the Linear application to easily facilitate. Instead of organizing through a disordered pile of customer notes every few months, continuous planners organize ideas into candidate projects as they arrive (and as of 2025, use AI to maintain them and keep them up to date). These projects form the center of gravity for both planning and execution. They are the most granular level an organization's leadership can be expected to reason about, and they are the highest level concept that contributors are expected to think about on a day-to-day basis. It's an approach that alleviates the pressure of a blank page and the recency bias that can compromise planning. Under continuous planning, you've been accumulating and organizing ideas all along, so that by the time you actually sit down to map your team's work for the next quarter, a well-vetted list of possibilities is already waiting for you. Organize your backlog around candidate projects Project ideas can originate from

## Designing remote work at Linear

DevFeed: [Designing remote work at Linear](<https://devfeed.tech/articles/designing-remote-work-at-linear-83545.md>)

Original publisher: [Read original article](<https://linear.app/now/designing-remote-work-at-linear>)

Published: 2025-10-29T17:09:18Z

Content type: article

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [engineering-leadership](<https://devfeed.tech/topics/engineering-leadership.md>), [Self-organizing Team](<https://devfeed.tech/topics/self-organizing-team.md>)

Tags: [autonomy](<https://devfeed.tech/tags/autonomy.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [how-we-work](<https://devfeed.tech/tags/how-we-work.md>), [like](<https://devfeed.tech/tags/like.md>), [meetings](<https://devfeed.tech/tags/meetings.md>), [okrs](<https://devfeed.tech/tags/okrs.md>), [ownership](<https://devfeed.tech/tags/ownership.md>), [people](<https://devfeed.tech/tags/people.md>), [product](<https://devfeed.tech/tags/product.md>), [quality](<https://devfeed.tech/tags/quality.md>), [remote-work](<https://devfeed.tech/tags/remote-work.md>), [team](<https://devfeed.tech/tags/team.md>)

### AI overview

Linear describes its remote first work culture, built around trust, autonomy, focused work, small teams, and shared ownership. The article also covers product and engineering practices, company gatherings, coworking hubs, and employee ownership.

### Source excerpt

When we began back in 2019, building remote-first was a design choice. We believed builders deserve freedom: freedom of place, freedom of rhythm, freedom of deep focus. And we believed quality doesn't come automatically, it needs to be intentional. That's why we built Linear around trust and autonomy. We wanted to give people space to do their best work, without extra layers of process. That vision still shapes how Linear works. Today, our 99-person team spans more than 15 countries and 10 time zones. Because we are distributed, each year we bring our whole team together in one place. This year it was Copenhagen, where we spent a week working side by side, sharing ideas, and aligning on what's next for us as a company. We wanted to capture what working at Linear feels like, so we brought a film crew along with us. They joined us for team sessions and other activities, filming the moments that make Linear what it is. Along the way, they interviewed members of our team who talked about what being remote-first means for us, how we stay connected across time zones, and the ways we come together in person throughout the year. We wrapped that footage into this video, which shares what it's like to work at Linear, told through the people who build it every day. How we work We maximize for trust in our builders. Teams set their own rhythms, communicate directly, and keep meetings to a minimum. There are few distractions, and a shared respect for uninterrupted focus. Deep thinking time is treated as something worth protecting. We believe that quality compounds when work has time to develop. At Linear that means: Small teams, clear ownership. Two to four people is typical. Teams assemble around a project and disband when done. Project leads rotate. Often engineers or designers lead. One product team, one roadmap. We do not use OKRs or run A/B tests. We align on a north star and make decisions with judgment, customer insight, and taste. Short specs, fast feedback. Specs focus

## Self-driving SaaS: When software runs itself

DevFeed: [Self-driving SaaS: When software runs itself](<https://devfeed.tech/articles/self-driving-saas-when-software-runs-itself-83577.md>)

Original publisher: [Read original article](<https://linear.app/now/self-driving-saas>)

Published: 2025-10-22T16:33:34Z

Content type: opinion

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [Product Management](<https://devfeed.tech/topics/product-management.md>), [Loop Engineering](<https://devfeed.tech/topics/loop-engineering.md>), [AI Context Switching](<https://devfeed.tech/topics/ai-context-switching.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [coding-agent](<https://devfeed.tech/tags/coding-agent.md>), [project-management](<https://devfeed.tech/tags/project-management.md>), [saas](<https://devfeed.tech/tags/saas.md>)

### AI overview

The article argues that AI in project management software should move beyond chatbot helpers that respond to prompts toward systems that proactively advance product work. It describes a vision in which AI extracts customer requests, creates and assigns issues, dispatches simple changes to coding agents, and handles selected work autonomously while people retain control over priorities and review results.

### Source excerpt

Traditional business software has always existed to facilitate and guide human actions. It creates efficiency through its constraints, capabilities, and nudges, but its ultimate value is only as great as the effort users put into it. Project management software is a good example. It establishes channels for a well-defined set of human actions: users create and triage issues, merge duplicate bug reports, and write updates as projects advance. The software provides all sorts of supports, reminders, and guardrails, but human users still do the work. Enter the Chatbot Era The first instinct that many incumbents have had with AI has been to layer a helper chatbot on top of existing systems. You can prompt the chatbot to draft a document, tell it to create a research report, ask it to group or categorize items, or otherwise enlist it to operate your app. These chatbot workflows can look magical in a demo, but they're really just the old ways of working dressed in a new interface. Human users are engaged in all the same tasks they've always been. They're still nudging the system along every step of the way, only now using prompts instead of button presses. Self-driving software Real change comes when AI stops requiring constant input and instead proactively moves work forward. Rather than constantly requiring user attention and input, the systems of the future will be self-driving. In our project management example: Customer requests are automatically extracted from inbound support tickets, customer research, and sales calls. Any communication the organization has with its current or potential customer base is used as context by the system for generating new issues and requirements. Newly created issues are analyzed, researched, and automatically assigned to the correct team, project, and person. The system uses the past completion history, existing backlog, and future roadmap as context to understand what to do. Simple changes are dispatched to a coding agent and complete

## A Linear spin on Liquid Glass

DevFeed: [A Linear spin on Liquid Glass](<https://devfeed.tech/articles/a-linear-spin-on-liquid-glass-83564.md>)

Original publisher: [Read original article](<https://linear.app/now/linear-liquid-glass>)

Published: 2025-10-21T16:32:42Z

Content type: article

Language: en

Sources: [Linear](<https://devfeed.tech/sources/linear.md>)

Topics: [liquid glass](<https://devfeed.tech/topics/liquid-glass.md>), [User interface design](<https://devfeed.tech/topics/ui-design.md>), [Design system](<https://devfeed.tech/topics/design-system.md>), [UI/UX Design](<https://devfeed.tech/topics/ui-ux-design.md>), [iOS](<https://devfeed.tech/topics/ios.md>)

Tags: [app](<https://devfeed.tech/tags/app.md>), [apple](<https://devfeed.tech/tags/apple.md>), [build](<https://devfeed.tech/tags/build.md>), [design](<https://devfeed.tech/tags/design.md>), [design-system](<https://devfeed.tech/tags/design-system.md>), [development](<https://devfeed.tech/tags/development.md>), [ios](<https://devfeed.tech/tags/ios.md>), [ios-26](<https://devfeed.tech/tags/ios-26.md>), [liquid-glass](<https://devfeed.tech/tags/liquid-glass.md>), [mobile-app](<https://devfeed.tech/tags/mobile-app.md>)

### AI overview

Linear redesigned its mobile app around a customizable navigation system for users with different roles. The article explains why the team recreated a Liquid Glass-inspired material instead of relying on Apple's APIs, including details of its SwiftUI and GPU-based effects, expandable tab bar, and accessibility behavior.

### Source excerpt

Earlier this year, we were ready to redesign our mobile app. The original version had served us well, but it was built with a narrow use case foremost in mind: individual contributors engaging with issues. A year later, Linear is the product development platform of choice for larger, more complex organizations, and the app wasn't serving everyone equally well. In particular, executives and managers want an overview of what's happening across their teams and the existing structure, optimized for a single workflow, couldn't easily support that. We knew we needed a more customizable foundation that would allow us to make the navigation more flexible, adaptable, and expandable depending on a user's role. Then in June, something fortuitous happened: Apple announced Liquid Glass at WWDC. We watched the keynote and right away it was clear Apple had landed on a design language that felt modern and expressive. It also matched the aesthetic shift we were already imagining. But as we explored it more closely, we realized adopting Apple's new APIs wouldn't give us the control we needed to build the customizable navigation that was the real purpose for our redesign. Instead, we decided to recreate our own version of Liquid Glass. We wanted to capture what we loved about it while retaining the flexibility to design a navigation experience that fits the way people use Linear. It was without question the harder path. We have a small iOS team--just two engineers--and fully adopting Apple's APIs would have been much simpler. But rebuilding it ourselves would allow us to bring our new navigation to all of our users, including those on iOS 18, while freeing us from the compromises and uncertainty that come with depending on someone else's design system. We knew that Liquid Glass had remained a moving target throughout the beta period of iOS 26, and Apple is still making changes to it today (like the recently introduced Tinted Glass option). It was a go-big-or-go-home moment, which made t

[Next page](<https://devfeed.tech/sources/linear.md?cursor=WyIyMDI1LTEwLTIxVDE2OjMyOjQyKzAwOjAwIiwgImM2OTBjODM5LWE1ZTUtNDczYy1iM2RjLWFjNjBkMTcyMzU0YyJd>)