Macro vs Linear

We loved Linear. Before we built Macro we ran our own company on it, and our task system is openly inspired by it: the same keyboard-first speed and design principles.

The problem is as Linear says themselves...

Indeed, issue tracking is dead. Agents killed it.

Of course, Linear is now tying to adapt from being an issue tracker to an agentic system, but it is still a tracker at its core. Linear is brilliant at the slice of work that lives inside Linear, and then it hands you off to Slack for the conversation, Gmail for the customer, your Notion for the docs, and GitHub for the code.

When we used to use Linear, this was our core problem: it was never up to date. The real conversation was not happening in Linear, it was happening in Slack. Architecturally, tasks should not be a separate thing from the rest of the work, they should be part of the same system.

On the other hand, Macro is a complete workspace. Macro keeps tasks in the same @linked system as email, messages, agents, docs, calls and CRM.

At a glance

Linear-inspired speed, without the separate tool

The bar Linear set is the bar we built to. Hit c then t from anywhere in Macro and a task-creation modal appears; tasks are quick to create, assign, prioritize and close out without ceremony. The whole thing is keyboard-first and fast, because like Linear we think the speed of creating an issue is the thing that decides whether issues actually get created.

What you do not have to do is leave the rest of your work to get there. In a Linear-shaped stack, tracking lives in one tab and everything that generates the work, the email, the bug report in chat, the decision on a call, lives in others. In Macro the tracker is one keystroke away from all of it, because it is the same app.

Create a task from anywhere in your work

Most tasks are born somewhere else: an email from a customer, a line in a spec, a comment on a call. Linear handles this with integrations that pull issues in from the outside. Macro handles it because the outside is already inside.

Create a task from an email by hitting the task button on the message. Drop to-do boxes into any markdown area, highlight them, and turn the whole set into tasks at once. Every task you make this way is linked back to its source bidirectionally, so the task remembers the email it came from and the email knows the task exists. Nothing falls into the gap between two apps, because there is no gap.

Tasks live in your channels

Channels are where work actually gets talked about, so that is where Macro lets you turn talk into tasks. Mention @Macro in a channel and ask it to create a task, or several, from what was just said. Click Create task on any message to deterministically spin one up, bidirectionally linked to that message so the conversation on the task and the conversation in the channel stay deep-linked. Paste a task link into a channel and it renders as an enriched pill showing status, assignee and priority.

This is the part a standalone tracker structurally cannot do well. Linear can be notified about a Slack thread; it cannot be the same thing as the thread. In Macro the message and the task are two views of one object.

Linked to GitHub, both ways

For engineering work, Macro tasks link to GitHub bidirectionally and to the agents working on them. Click the GitHub pill to jump from a task to its pull request, or the other way around, all opening in a split inside Macro so you never leave your workspace.

The integration goes one step further into your inbox. GitHub's own notifications are famously easy to miss, so Macro brings the PRs where you are the author, are mentioned, or get a comment into your unified inbox alongside your messages, tasks and important email. You stop checking three places to find out a review came in, and team velocity goes up for the boring reason that nothing waits unseen.

What we took from years of running on Linear, and why we eventually wanted tasks to live next to everything else.

Shared memory across your whole team

This is the thing a single-purpose tracker simply does not have. Macro builds memory from everything: your docs, your email, your tasks, your channels, your calls, and the deals moving through your CRM, and it does it across your whole team, not just you. It refreshes nightly.

Because the memory spans the company, the agents can do task work a standalone app cannot. Macro can assign a task to whoever actually owns that area, route an incoming customer report to the right person, or tell you who to ask about a piece of code. None of that is technically impossible for an isolated tracker to attempt; it just cannot be done well, because no tool that only sees issues has the right to reason across all of your work. A unified workspace does.

Everything links to everything

In Linear you link issues to issues, and to PRs and a handful of connected apps. In Macro you can @-mention anything in your company from a task: a doc, a file, a customer email, a support ticket, a channel message, a recorded call. The links are bidirectional, so the task and whatever it touches both know about each other, and your workspace becomes context you can navigate in either direction.

That web is also how permissions work, which removes a whole class of friction. Anything you @-mention in a channel is shared with the people in it; join a channel and you gain its context, leave and you lose it. There is no access-request dance, because membership is the permission.

More than a tracker: email, chat, calls and a CRM

The honest framing is that this is not a comparison of two issue trackers. Linear tracks issues, beautifully. Macro tracks issues and is also your email client, your chat, your docs, your calls and your CRM. The email is Superhuman-fast on your own database. The channels are quieter than Slack with a real inbox. Calls record and transcribe by default and feed the same memory. The CRM updates itself one block away.

So putting Macro next to Linear is really putting one fast, linked app next to a tracker plus the four other tools you keep open around it. If your tasks never had to leave the room where the rest of the work happens, that is the difference you are buying.

Where Linear still wins

Linear is genuinely better at several things, and we are not going to wave them away. Its project, cycle and roadmap tooling is deeper than ours, its triage, insights and workflow customization are more mature, and it has years of polish and integrations aimed squarely at dedicated engineering organizations. If issue tracking is the center of gravity for your whole company and you want the most powerful purpose-built tracker that exists, Linear is the right call and you should keep using it. Macro's tasks are excellent, but they are one block in a suite, not a decade-deep project-management product.

Who should switch to Macro

The switch makes sense when your setup is Linear plus Slack plus a mail client plus docs plus a CRM: five tools that do not share context, five interfaces to check, five bills that grow with headcount. That is exactly the stack Macro collapses into one fast app with one memory across it. The low-risk way in is to run Macro alongside Linear for a week, create tasks from your real email and channels, wire up GitHub, and see how much of the context-switching simply disappears before you decide what comes across.

Full comparison

FAQ