AI that reaches into Linear and Figma

I wrote before about context engineering, giving an AI agent the whole stack. MCP, the Model Context Protocol, is how a lot of that context actually arrives. It lets the agent reach the tools where the work already lives, instead of me copy-pasting between tabs. Two that changed my day-to-day are Linear and Figma.

Linear: start from the real ticket, not my paraphrase

With the Linear MCP, my agent can read the actual issue: the description, the acceptance criteria, the comments, the linked context. That sounds small until you notice how much gets lost when a person relays a ticket to an assistant in a sentence or two. Working from the source, the agent builds the thing that was actually asked for. It can also move the issue along: leave a comment with what it did, update the status, break a large issue into sub-tasks. The ticket stays the source of truth, and the agent participates in it instead of working beside it.

Figma: build from the real design, and the real components

The Figma MCP does the same for design. Instead of eyeballing a screenshot, the agent pulls the design context directly: layout, spacing, the design tokens, the component structure. The part that matters most for us is Code Connect, which maps a Figma component to the actual component in our design system. So when the agent turns a design into code, it reaches for our real Button and our real Card, with our tokens, rather than inventing a one-off that looks close and quietly drifts from the system. Design-to-code that respects the design system is the difference between a useful draft and a mess to clean up.

Why MCP specifically, and not just “AI”

The model is not the interesting part anymore. Access is. A capable model with no context guesses; the same model with the ticket, the design, the codebase, and the product data reasons. MCP is the plumbing that delivers that context in a standard way, so I am not hand-building a bespoke integration for every tool. Connect the tool once, and the agent can use it.

The loop it closes

Put together, the flow is tight: the requirement lives in Linear, the design lives in Figma, the code lives in the editor, and the agent can see all three at once. Less translation loss between them means fewer rounds of “that is not quite what the ticket said” or “that is not the component we use.” The tools stop being separate tabs I shuttle context between and start being one connected workspace the agent works inside.

A note on trust

Access cuts both ways, so I keep the agent’s reach deliberate. Reading tickets and designs is safe and high-value. Writing, like moving issues or leaving comments, I keep intentional and reviewable. The goal is an agent that is well-informed, not one that changes things behind my back.