Fewer tabs. More code. More focus.
Context: the tools used as examples
Throughout this article, I'll use the stack we rely on daily as examples — but the concept applies to any combination of tools. If you work with different tools, the logic is the same: only the tools change, not the problem.
The tools featured here are:
- GitHub — where code lives: repositories, Pull Requests, branches, and commit history
- Linear — task and project management, a more modern equivalent of Jira or Trello
- Rollbar — production error monitoring that captures exceptions and stack traces in real time
- Figma — interface design tool where layouts and visual components are created
The Problem Nobody Measures
Have you ever been in the middle of a debugging session, opened your browser to check some documentation, ended up on a YouTube tab, and when you came back... completely lost your train of thought?
That's not a lack of focus. It's the invisible cost of a fragmented workflow.
The typical workday involves a constant dance between tools: the design is in Figma, the code and PRs are in GitHub, the tasks are in Linear, the production errors are in Rollbar. Each tool lives in its own world, and the developer is left as the human link between them all — manually, all the time.
The result? Lost productivity, frustration, more mistakes from distraction, and wasted hours that never show up in delivery reports. It's not a lack of skill. It's an excess of friction.
What Are MCPs?
MCP stands for Model Context Protocol — a standard protocol for connecting LLMs (Large Language Models) to external data sources and tools in a structured way.
In plain terms: MCP is what allows AI to access your tools and act on your behalf.
Instead of you going to Linear to find an issue, the AI goes there and brings back the answer, right inside your editor. The flow looks like this:
Developer → LLM/AI → MCP Server → Tools (GitHub, Linear, Rollbar, Figma)
You stay at the center, without leaving your place.
Before vs. After
Without MCPs — the manual path:
1. Open the browser
2. Open Linear
3. Search for the project
4. Find the issue
5. Open Rollbar
6. Find the related error
7. Open the editor
8. Start debugging
With MCPs — you ask, the AI handles it:
1. Ask the AI: "What's the status of issue INK-1234?"
2. The AI uses the Linear MCP, GitHub MCP, and Rollbar MCP
3. You get a full summary right in your editor
The 4 MCPs That Transform Your Daily Workflow
🐙 GitHub MCP
- Read and create Pull Requests automatically
- Search code across any repository in your account
- Analyze commits, branches, and change history
- Generate PR descriptions following your team's templates and standards
A real use case: instead of manually reviewing each PR by opening GitHub, you ask the AI for a prioritized summary of pending PRs and review the most urgent ones first.
📋 Linear MCP
- Browse all issues in a project without opening your browser
- Create and update issues directly from your editor
- Retrieve full context on projects and sprints
- Sync status with PRs via branch name
Practical tip: If you just got back from vacation, simply ask: "Which issues are currently in development on project X?" — without ever opening Linear.
Known limitation: The Linear MCP can't yet create projects or access project files. For that, Linear itself has launched a native agent.
🐛 Rollbar MCP
- Investigate production errors with full context
- Pull stack traces and recent occurrences automatically
- Identify similar bugs already on record
- Understand where and why an error is happening
Ideal for bugs in parts of the system you're unfamiliar with: the MCP goes to Rollbar, analyzes the stack trace, identifies the context, and already suggests where to start debugging — all without leaving your editor.
🎨 Figma MCP
- Extract design specs (spacing, sizes, colors)
- Generate component code from layouts
- Take design screenshots for visual validation
The differentiator: when the Figma MCP accesses a file, it brings a screenshot directly into the chat so you can validate whether the generated code actually matches the design — without opening Figma, without copying styles manually.
Real Example: Investigating a Bug
Without MCPs (8–15 minutes, open to context loss)
1. Open Rollbar in the browser
2. Search for the error manually
3. Copy the stack trace
4. Open Linear
5. Search for the related issue
6. Copy the branch name
7. Open GitHub
8. Find the related PR
9. Read the PR code
10. Return to the editor
11. Start debugging
⏱️ Time: 8–15 minutes (or more)
😫 Context: LOST
With MCPs (20–30 seconds of prompting, context preserved)
You: "Investigate the checkout error that appeared in Rollbar"
AI with MCPs:
✓ Rollbar MCP: fetches the error and stack trace
✓ Linear MCP: finds issue INK-1234
✓ GitHub MCP: locates related PR #5678
✓ Delivers a full summary with a debugging starting point
⏱️ Time: 20–30 seconds of waiting
🎯 Context: MAINTAINED
Same task. Minutes turned into seconds. And most importantly: you never lost your train of thought along the way.
Why Context Is Your Most Valuable Resource
Every time you leave your editor to find information, there's a real cognitive cost to getting back on track. Productivity research shows it can take more than 20 minutes to fully regain focus after an interruption.
That cost accumulates silently — hours per week — and never shows up in task estimates.
With MCPs, the flow becomes:
Developer 🧑💻 → Asks the AI → MCP fetches → Answer in context → Stays focused 🎯
The practical result: less stress, higher quality code, and more deliveries. All without radically changing the way you work.
How to Write Good Prompts for MCPs
The quality of results depends heavily on how you instruct the AI. Some practices that work well:
Be specific about context:
"I'm running the Rollbar cycle project this month. List all issues in the backlog."
Combine MCPs in a single instruction:
"Investigate the error at [Rollbar URL], check if there's a related issue in Linear, and bring me a summary of the linked PR."
Provide context for implementations:
"Implement the issue [ID]. Use components from the design system, check the design in the Figma link referenced in the issue description, and add the link to the admin navigation menu."
Write well-structured issues in Linear:
The more context is in the issue (links, technical specs, etc.), the better the implementation results will be.
The Future: From Executor to Orchestrator
The developer's role is changing — and that change has already begun.
| Today | Tomorrow |
|---|---|
| Executor of operational tasks | Orchestrator of intent and architecture |
| Searches for information manually | Defines what needs to be done |
| Integrates tools one by one | Validates and refines what the AI delivers |
| Spends time on repetitive tasks | Focuses on strategic decisions and creativity |
This isn't about replacement. It's evolution. The AI takes on operational and repetitive tasks; the developer steps into the role of project engineer — defining the architecture, reviewing what was built, ensuring quality.
Those who adapt first come out ahead. Not because they'll write more code — but because they'll orchestrate what already exists more effectively.
Next Steps
1. Explore
Map the tools you use most in your daily routine and check if an MCP already exists for them — the ecosystem is growing fast, and there's a good chance someone has already built what you need. Start by testing a flow you currently do manually and compare the result.
2. Adopt
Pick a single MCP — the one most relevant to your current routine — and integrate it into your workflow for a few days. Seeing the results in practice is what truly convinces you, and it's easier than it sounds.
3. Build
If you identify a tool that doesn't have an MCP yet, consider building your own. The protocol is open and well-documented, and relatively simple MCPs are already capable of automating entire workflows within your domain.
You don't need to change everything today. Start small, think big.
The future of development isn't writing more code — it's orchestrating what already exists more effectively. 🚀
Top comments (0)