Everybody’s talking about MCP for good reason. In my product org, it has moved AI from clever demos to dependable, value-creating workflows. When I compare notes with builders at Miro, Atlassian, and beyond, the same patterns surface again and again: nail your retrieval strategy, design for safe tool use, instrument like you mean it, and let real workflows—not novelty—set the agenda.
When I say MCP, I’m talking about the Model Context Protocol (MCP): a practical way to connect LLMs to tools, data, and actions so agents can retrieve, reason, and execute inside real product experiences. It sounds simple; in practice, it forces you to align AI workflows with everything from data governance and observability to UX writing and change management. That alignment is where the wins live.
Here is the playbook I now use, refined through our launches and lessons I’ve absorbed from teams at Miro and Atlassian who are shipping agentic AI into complex, high-trust environments.
Start with a retrieval-first pipeline. Fancy tools won’t matter if the model’s context is stale, noisy, or mis-scoped. I treat retrieval as a product in itself: define authoritative sources, normalize them with docs-as-code discipline, and tag them for permission-aware filtering. Then I enforce context window management so the agent sees the smallest, highest-signal slice of data needed for the task. Good retrieval shrinks hallucination risk and makes every downstream tool call more accurate and cheaper.
Map one golden path before you expand. In our first MCP rollout, we picked a single, high-frequency workflow with a clear outcome: summarize a Miro board into action items and push them to Jira without manual copy-paste. That forced us to design the end-to-end contract between retrieval, reasoning, and action. Only after the golden path hit reliability targets did we layer on variants (e.g., Confluence summaries, epic splitting, backlog grooming). Narrow to go fast; broaden to scale impact.
Instrument like a modern platform, not a demo. I apply eval-driven development to MCP agents: offline test suites for intent classification and tool selection, online shadow evals to watch live drift, and post-deployment regression checks that fail closed when data contracts or tool permissions change. Pair that with granular observability so I can trace each agent turn: prompts, retrieved chunks, tool inputs, and outputs with latency and error codes. Without this, you’re guessing. With it, you can iterate weekly.
Design for least privilege and graceful failure. MCP makes it easy to connect many tools; that’s exactly why you must scope access narrowly and log everything. In our stack, every tool call has a scope, a human-readable rationale, and an audit trail. If a call fails, the agent must recover: retry with backoff, fall back to read-only, or ask the user for consent or missing context. Teams at Atlassian have repeatedly emphasized how permission hygiene and auditable behavior build trust at enterprise scale; my experience matches that.
Adopt CI/CD for prompts and policies. I treat prompts, tool schemas, and guardrails as versioned artifacts behind feature flags. That lets us canary changes to a small cohort, A/B test prompt variants, and roll back instantly if we see regressions. In practice, this is the difference between shipping one-off AI features and running a resilient AI platform. You’ll feel the leverage as soon as you ship your second iteration.
Make tool choice explicit and inspectable. Agentic AI can feel opaque; I push for transparent tool arbitration. The agent must explain why it’s about to use a tool, show the proposed inputs, and surface the expected side effects. For power users, a reveal panel with retrieved sources, tool candidates, and confidence signals turns a black box into a glass box—especially valuable in collaborative canvases like Miro and structured work hubs like Jira and Confluence.
Optimize for latency budgets users can feel. Multi-hop reasoning and multiple tool calls can degrade experience quickly. We set strict latency budgets by task type, apply caching on stable retrievals, parallelize safe calls, and prefetch likely context from the user’s session. If the task will exceed budget, the agent tells the user what it’s doing and delivers progressive results. Miro teams talk about protecting flow; Atlassian teams prioritize continuity in tickets and docs. Same principle: respect momentum.
Treat prompt engineering as UX writing with systems thinking. The most reliable prompts combine plain-language intent, domain constraints, and crisp tool contracts. We align style and tone with our brand, and we embed microcopy that teaches users how to ask for the best results. Tooltips, in-app guides, and examples reduce churn and boost user activation without retraining the model.
Meld product strategy with AI feasibility. I start roadmapping by outcomes, not model tricks: time saved in backlog grooming, higher-quality meeting notes in Confluence, or fewer context switches across Miro boards. Then I map feasibility: retrieval coverage, tool maturity, safety constraints, and the eval harness needed to prove gains. This keeps the team focused on value propositions customers feel, not only on what’s technically novel.
Staff the right trio and the right rituals. My most effective MCP teams operate as empowered product teams: a product manager who owns outcomes and risk posture, a forward-deployed engineer who shapes tool schemas and platform scalability, and a designer who sweats conversational flows and recovery states. Weekly eval reviews replace vague demo days. We ship small, learn fast, and document what changed.
Measure what matters, not just what’s easy. Beyond engagement, I track success with a ladder of metrics: task success rate, time-to-completion versus baseline, user edits per output, defect rates caught by evals, and downstream business impact (activation, retention, NRR lift). When a workflow moves these needles for a defined segment, I know we’re ready to scale or cross-sell.
Expect tool sprawl and plan for governance. MCP’s superpower is extensibility; its weakness is the same. We maintain a curated tool catalog with owner, scope, schema version, and deprecation policy. We lint schemas in CI, require backward-compatible changes, and sunset unused tools quarterly. This reduces the blast radius of change and keeps the platform evolvable.
Bring your ecosystem with you. The best results come from integrating into existing systems of record and systems of collaboration. At Miro, collective context lives in boards; at Atlassian, it lives in tickets, docs, and runbooks. Your MCP strategy should amplify those collaborative truths—pull the right context at the right moment and write back where people already work.
A 30-day MCP starter blueprint I recommend looks like this. Week 1: pick one golden path, map permissions, define success metrics, assemble your eval harness. Week 2: build retrieval-first pipeline and a minimum set of tools with least-privilege scopes. Week 3: wire agent reasoning with transparent tool arbitration, ship to an internal pilot behind feature flags, instrument everything. Week 4: harden with evals, optimize latency, tighten UX microcopy, and open a limited beta with a product tour and clear feedback loops.
Looking ahead, the next frontier is composable agents that coordinate across products and teams without stepping on governance landmines. With a disciplined retrieval-first pipeline, strong observability, and eval-driven development, that future is within reach. MCP isn’t magic; it’s a platform pattern. Treated that way, it compounds.
If you’re wrestling with where to start, choose one workflow users do every day and make it unambiguously better. When your agent quietly handles the busywork and your metrics confirm the lift, skeptics turn into champions. That’s been my experience—and it’s the common thread I keep hearing from builders at Miro, Atlassian, and beyond.
Inspired by this post on Pendo – Best Practices.
Leave a Reply