We Rebuilt our Onboarding Around MCP: The Result, 3X SDK Installs

TL;DR

• We rebuilt onboarding around our MCP (Model‑Context‑Protocol) integration so developers start inside their editor with our SDK—not a detour through example apps or sandboxes.
• Early results: ~3× more users reach SDK install versus our previous flow, and they see real product value sooner.
• This piece shares why we made the change, how the MCP‑centered flow works, what we learned, and what’s next.

🎥 Demo: Watch the new onboarding flow

Why Change at All?

Our north star for onboarding has always been simple: get users to the “aha” moment fast. With a SDK‑based product, that “aha” usually requires installing the SDK into the user’s own app—and that’s exactly where friction creeps in.

We had invested heavily in a guided tutorial with three flavors:

• No‑code, in‑browser walkthrough
• Code sandbox to see real code without installing
• Example app that users could install locally

Developers (our core audience) were routed to the code sandbox and example app paths, and we encouraged the example app because it provided a convincing, runnable experience. In practice, most users skipped the flow altogether—likely because even a “simple” example app install feels like a detour when all you want to do as a developer is explore the tool and decide if you want to try the SDK in your codebase.

Net effect: even when users did the tutorial, they still had to figure out the SDK install on their own to get to real value.

What the Old Example App Flow Did Well (and What it Didn’t)

What it did:

1. Collected a bit of profile data (e.g., "Developer that uses React + OpenFeature”).
2. Prompted an npx command to spin up a pre‑keyed example app.
3. Waited for a “run” event to unlock the tutorial.
4. Guided users through feature flag basics and our core concepts.
5. Dropped them into the dashboard to continue exploring.

What it did well:

• Explained the core concepts of the DevCycle platform, quickly and effectively
• Displayed a heightened level of interest and commitment to learning about the platform

Where it fell short:

• Perceived complexity → high skip rate.
• Off‑trajectory → even “successful” users still weren’t running our SDK in their actual app.
• Indirect value → the best path to “aha” (SDK in their app) wasn’t the path this onboarding flow optimized for.

Why MCP?

MCP lets an AI coding assistant (like Cursor, Claude Code or VS Code) call into your platform and blend API operations with context‑aware prompts. That means we can:

• Orchestrate SDK install where developers already are—inside their editor.
• Detect language/framework and tailor the install.
• Create platform resources (e.g., a feature flag) directly from the assistant.
• Emit events back to our dashboard to progress the tutorial automatically.

In other words, this new world with AI assistants and MCP gives us a straight line from “sign up” to “SDK installed in your app,” without detours.

The New, MCP‑Centered Onboarding

As a part of the new flow, we compressed our onboarding into three guided steps, with MCP at the centre:

1. Install the DevCycle MCP
   • Identify your AI coding assistant (Cursor, Claude Code, VS Code, etc.).
   • Offer one‑click install or exact steps per assistant.
   • Authenticate; our platform listens for a successful “MCP ready” event and auto‑advances.
2. Install the DevCycle SDK (inside your repo)
   • You trigger a single prompt inside your assistant: “Install the DevCycle SDK.”
   • Behind the scenes, your coding agent detects your app’s language/framework and our MCP sends a precise, environment‑aware instruction set back (including your SDK key).
   • We verify install and auto‑advance again.
3. Create a “Hello World Banner” behind a feature flag
   • A second prompt: “Create a Hello World banner and gate it behind a flag.”
   • Our MCP creates the Feature and Variable, wires up the client code, and returns the context for toggling.
   • The dashboard confirms each step and shows you the live feature.

From here, you can explore in the dashboard or continue inside your AI coding assistant—whichever suits your workflow.

Before vs. After (At a Glance)

Under the Hood: How it Works

• Assistant detection & instructions
  Users pick their coding assistant; we present the right MCP install steps or one‑click options (e.g., Cursor, Claude Code or VS Code).
• Language & framework detection
  The MCP leverages the AI coding assistant to inspect the workspace and infer stack + package manager. The MCP dynamically provides a detailed install prompt back to the AI coding assistant with a full install plan (e.g., dependencies, env variables, initialization code).
• Eventing for progress
  The DevCycle platform listens for MCP and SDK lifecycle events (MCP installed, SDK initialized, Variable evaluated). Each event auto‑unlocks the next step and surfaces validation feedback.
• Two prompts, real work
  We intentionally keep prompts minimal and handle the heavy lifting in the MCP:
  1. “Install the DevCycle SDK.”
  2. “Create a Hello World banner feature and gate it behind a flag.”

Everything else—the specificity, the code edits, the platform calls—happens via the DevCycle MCP + your AI assistant.

Results so far

• ~3× increase in users reaching SDK install compared to the old flow.
• Fewer "skips" - the path feels “native” to how developers already work.
• Faster time‑to‑value - live feature flag within minutes, not after a separate tutorial track.

We’re obviously being careful here: onboarding metrics evolve as traffic and cohorts change. But directionally, focusing on MCP has moved users down‑funnel faster and with less drop‑off.

Learnings for Others That May Want to Leverage MCP in a Similar Way

• For product managers
  Treat MCP as a product surface, not just “AI glue.” When your “aha” requires installation or configuration, MCP can relocate that friction from a browser wizard to a context‑aware assistant in the user’s real environment.
• For product engineers
  MCP gives you a deterministic orchestration layer for otherwise brittle “copy/paste this code” moments. With stack detection, targeted API calls, and event hooks, you can ship guided automation that still leaves users in control.
• For AI enthusiasts
  This is a practical, non‑demo use of AI agents: let the assistant perform structured, reversible changes (dependencies, config, code scaffolding) and reflect success back to the product in real time.

What’s Still Rough (and How We’re Handling It)

• MCP install/auth friction
  It’s better than asking users to install an entire example app, but the install/auth handshake of the MCP itself is still more steps than we’d like. This is likely something we can't fix on our own but something that will change over time as MCP is more widely adopted.
• Non-deterministic behavior
  Given generative AI is non-deterministic it doesn't matter how verbose and specific your underlying prompts are, AI may not do what you expect. We protect for this with permissions and API guardrails on destructive actions and by giving users an easy out of the onboarding flow if AI does something unexpected.
• Trust & reversibility
  AI editing code can make people nervous. But with the current state of AI coding assistants all changes are transparent and diff‑able, and we scope actions to a clearly defined surface (config, init, feature scaffolding).

Implementation Notes (For the Curious)

• Event model: mcp_installed → sdk_initialized → variable_evaluated. Each event emits an SSE event on a channel dedicated to your browser session and unlocks UI states.
• Prompt design: human‑readable requests paired with tool‑centric instructions (package manager commands, file paths, code snippets) only visible to the assistant via MCP.
• Safety rails: explicit prompt guidance on things to avoid, API guardrails for destructive events (i.e. blocking deletion) and a “skip this” option always available, in case AI decides to take a detour that can't be easily corrected.

Where We’re Taking This Next

• Deeper “day‑1” recipes for example progressively enhancing the Hello World banner into more real-world examples where possible.
• Continuing to enhance the MCP with additional tools like the ability to assist with code migrations from other Feature Flagging platforms.

Wrap‑up

MCP is new, and parts of the install/auth experience are still rough around the edges. But even today it meaningfully reduces friction for SDK‑based products. For us, focusing onboarding on MCP shifted the experience from learning about DevCycle to using DevCycle—inside the user’s own codebase, within minutes, driven by simple natural‑language prompts.