DEV Community: DevCycle

What We Shipped in Q3: User Debug Tools, AI-Generated Features and More 🚀

DevCycle — Wed, 05 Nov 2025 20:20:17 +0000

In the last few months the DevCycle team released a ton of upgrades including; a suite of debugging functionality, powerful AI-assisted tooling and new observability integrations. Combined, this functionality makes it even easier to understand how your features behave in production.

🧩 User Debug Tools

The new suite of Debug Tools: Evaluation Lookup, Point-In-Time Simulation, Live Events and the Web Debugger, make it easier to validate, troubleshoot, and understand how your Features behave for specific users, all without leaving the dashboard.

If you need to figure out why a User is being served a specific variation of a Feature, one of these tools is sure to help! Keep reading to learn more about each tool.

🔎 Evaluation Lookup

What it is: Inspect how and why a specific user received a variation.

View complete evaluation reasons, targeting matches, and environment context to confirm whether a user met the correct targeting rules—fast.

Use when: A user reports seeing the wrong variation, or when validating feature rollouts before production.

📍 Point-in-Time Simulation

What it is: Simulate a user’s feature flags based on a historical project configuration.

Investigate regressions or unexpected behavior by viewing how a Feature (or Features) was evaluated for a specific user at any point in time.

Use when: Debugging incidents, reproducing user reports from a past date (especially after a Feature configuration change or rollbacks), or when leveraging Local Bucketing SDKs.

▶️ Live Events

What it is: Stream real-time variable evaluations, defaults, and custom events.
Watch variable evaluations, variable defaults, and custom events as they’re received from your application in real time—connected directly to the SDK event stream.

Use when: Verifying SDK event delivery, testing variable evaluations live, or ensuring custom events are being tracked correctly for yourself or a specific user.

🧰 Web Debugger

What it is: Embed DevCycle’s debugging tool directly into your application.

Override values using Self-Targeting for testing without code changes, and view live SDK events to monitor variable evaluations and confirm custom events are firing.

Use when: You want to debug or test your Features directly in-app without accessing the DevCycle dashboard.

Together, these tools make it simple to pinpoint flag logic, validate targeting, and troubleshoot issues faster—without digging through logs or guesswork 🚀.

🧠 AI-Generated Schemas & Feature Summaries

We’re bringing AI deeper into your DevCycle workflow. These new tools help automate some of the most time-consuming setup and documentation tasks for your team.

💂 AI-Generated Schemas
Variable Schemas protect your production environment by enforcing allowed values for Variables—but creating them manually can be tedious. With AI-Generated Schemas, DevCycle analyzes your existing Variable configurations and automatically builds a Schema that validates against those values. You can then fine-tune it as needed.

📋 AI-Generated Feature Summaries
Keep your teammates aligned without manual upkeep. AI-Generated Feature Summaries use your current Feature configuration to produce an instant, point-in-time description you can edit and share. Perfect for keeping documentation fresh and accurate.

📈 Dynatrace Integration

Send DevCycle Feature changes and runtime evaluations directly into Dynatrace so your teams can easily monitor app performance tied to flags.

Feature change events (targeting/variation updates) stream into Dynatrace via predefined workflows
Flag evaluation traces captured by OneAgent using SDK hooks
Prebuilt Dynatrace dashboard to investigate anomalies alongside feature context
Automatic environment mapping between DevCycle and Dynatrace

This integration adds Feature Flag evaluation data to your traces, helping with faster debugging, tracking rollbacks, and shipping with confidence 🚀

🛠️ General UX & Dashboard Improvements

Added Variable Schema creation directly in the Feature Overview
Added Environment “Last Modified” dates and deep links to Audit Log entries

We all hope our users find these new features and functionality valuable. We love feedback and requests, visit our public roadmap to weigh in!

Introducing the DevCycle MCP Server: Ship Flags Faster, Safely with AI Coding Agents

DevCycle — Fri, 24 Oct 2025 16:24:19 +0000

Read the original blog here

Why we built a MCP server for DevCycle

AI coding environments and agents are great at writing code—but the moment you need to create a feature flag, tweak targeting, or check an audit log, you’re back to context‑switching: open the dashboard, copy keys, run a CLI, paste results, repeat. That’s slow, error‑prone, and kills flow.

The new DevCycle Model Context Protocol (MCP) Server lets AI‑powered editors (Cursor, VS Code, Windsurf) and assistants like Claude Code talk directly to your DevCycle projects to do real work for you: create flags, manage variations and targeting, fetch SDK keys, pull audit history, and even report on evaluation analytics. No tab‑sprawl. No manual stitching of disparate contexts. Just ask, and it acts safely and with guardrails.

What we built

A hosted MCP server for DevCycle. It’s based on our CLI and exposed as a secure, OAuth‑backed MCP endpoint. Connect once; your client negotiates streaming (SSE) or HTTP, and you’re ready to go.

Hosted endpoints

Auto‑negotiating: https://mcp.devcycle.com/mcp
SSE‑only (fallback): https://mcp.devcycle.com/sse

Broad tool coverage

Feature and variation CRUD, targeting rules, variables, environments, and SDK keys, project introspection, self‑targeting overrides, and usage/evaluation analytics.

Production safety

Tools that can change production are clearly marked, and destructive actions require explicit confirmation.
The authentication ensures the MCP server respects the given user's permission level.

The problem DevCycle MCP solves (and how)

Before: Every time you create a new feature, you need to juggle whether to start in your IDE with the code or in the DevCycle interface to create the feature flag you're going to use. This is common with many actions and requires context switching. Sometimes, if you're using AI agents, you need to correct them when they do something before you're ready.

Now: your AI agent has direct access to DevCycle to take actions on your behalf, exactly when they make sense during the workflow.
You can ask things like:

“Create a new feature flag called new-checkout-flow.”
“Enable targeting for header-redesign in production.”
“Show me evaluations for pricing-experiment from the last 7 days.”

Under the hood, your agent speaks to our server via the MCP, which executes the appropriate DevCycle commands with your authorization and returns structured results your agent can reason about.

Why it’s unique

OpenFeature‑native platform: DevCycle is the first OpenFeature‑native feature flagging platform—built by OpenFeature governance contributors—so your MCP workflows align with the standard you already use in code.
Zero setup: It’s hosted and OAuth‑backed—no daemons, no ports. Connect and go; as long as you're authenticated, it's always running.
Wide, practical surface area: From flag creation to audit trails and evaluations, the toolset maps to day‑to‑day release management—not just cool tech demos.
Built for safety: Tied to your permission level via OAuth, with clear prod/destructive markers and confirmation flows. This ensures AI can't make destructive changes without your approval.

DevCycle MCP benefits at a glance

Fewer context switches, faster cycles: Stay in your editor/assistant and speak the task; it handles the rest.
Safer changes, clearer history: Toggle targeting or update rules with confirmations, then trace everything with audit logs.
Better integration: Because the DevCycle MCP can run locally or remotely, you can easily create your own service that leverages the MCP for customized workflows, like cross-referencing an Observability tool MCP with the DevCycle MCP to confirm if a flag change caused an incident.
Standards‑aligned: Plays nicely with OpenFeature SDKs and providers across your stack.

Get started (in under 2 minutes)

Pick your favorite AI agent and follow the instructions. For more detailed getting-started instructions, you can check out our docs.

Cursor

Install in Cursor

Or add to: ~/.cursor/mcp_settings.json:

{
  "mcpServers": {
    "DevCycle": { "url": "https://mcp.devcycle.com/mcp" }
  }
}

Then open Cursor Settings → Rules and Integrations → Click "Needs Login" to authorize (select your org if prompted).

VS Code

Install in VS Code

Or add to: .continue/config.json:

{
  "mcpServers": {
    "DevCycle": { "url": "https://mcp.devcycle.com/mcp" }
  }
}

Start the server in VS Code’s MCP panel, accept the auth dialog, and finish in your browser.

Claude Code

Open your terminal and run:

claude mcp add --transport http devcycle https://mcp.devcycle.com/mcp

In Claude Code, type:

/mcp
Select devcycle → Enter to login and complete the OAuth flow in your browser. When you return, the server will show as connected.

Prefer running the MCP locally? Install the CLI (npm i -g @devcycle/cli) and point clients at the bundled local dvc MCP server. Env‑var auth is supported for CI/CD.

What can you ask the DevCycle MCP to do?

The DevCycle MCP provides a complete selection of tools and prompts that together enable these popular use cases, among others:

Feature Creation

When creating a new feature in your code, you typically have to go back and forth between your IDE and DevCycle to create a Feature, get the relevant Variable for your code, implement that Variable and then wrap your code in the conditional. If you're using a coding agent to create the feature, it may make incorrect decisions about how to implement feature flags.

With the DevCycle MCP installed, your coding agent can handle the end-to-end of creating the Feature and Variable in DevCycle and then implement it in code to flag the new feature it started coding for you.

QA Testing

The DevCycle MCP enables natural language commands for configuring flags with DevCycle's self-targeting overrides. This gives your coding agent an understanding of the overrides set for your user and the ability to configure overrides on your behalf.

Testing a new feature locally is as easy as telling your coding agent to toggle a flag on or off, or you can give it more complex instructions on how to configure multiple flags in tandem for you, all without updating any targeting rules.

Audit Logging / Incident Research

Let's say an incident just kicked off, and you're in the middle of trying to determine if a code deploy or a feature flag configuration change may have caused the issue. Instead of hunting down relevant audit logs in DevCycle, you can now ask your coding assistant to list all changes to the production environment within a 30-minute range.

The DevCycle MCP will respond with all audit logs across all Features in your project filtered by your criteria, and then your coding agent can present that in an easy-to-digest way. Suppose you are running the MCP of an Observability tool in tandem. In that case, you can even have your coding agent cross-reference the errors to determine if any of the changes could plausibly have caused the issue, helping you and your team get to mitigation and resolution as quickly as possible.

Flag Cleanup

Cleaning up flags that are no longer needed is a tedious task that is often ignored in favor of new projects. This means that most teams that implement feature flags tend to keep those conditionals around longer than they would typically like. At DevCycle, we have already done a lot to help alleviate this problem, from providing Stale Feature Notifications to enabling easy automated cleanup of Variables via our CLI.

The DevCycle MCP is aware of the statuses of all of your DevCycle Features, so now you can have it take all Completed Features, read the values that are being distributed, and have your coding agent replace the stale Variables in your code with the relevant static values. All you have to do is review the code.

These are just a few examples of what you can do with the DevCycle MCP. To view all of the available tools, check out our reference docs.

Try it out now

Once you have installed and authenticated the DevCycle MCP, try asking your coding agent to:

“Create a new feature flag called new-checkout-flow.”
“List all features in my project.”
“Enable targeting for header-redesign in development.”
“Show evaluation analytics for the last 7 days.”
"Show me all flag changes on August 18."

About DevCycle

DevCycle is the first OpenFeature‑native feature flag management platform - so you can ship faster without vendor lock‑in. The MCP server extends that developer‑first experience right into your AI tools.

Try DevCycle for free no credit card needed!

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

DevCycle — Thu, 23 Oct 2025 19:05:06 +0000

Read our original blog here

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.

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:

Collected a bit of profile data (e.g., "Developer that uses React + OpenFeature”).
Prompted an npx command to spin up a pre‑keyed example app.
Waited for a “run” event to unlock the tutorial.
Guided users through feature flag basics and our core concepts.
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:

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.
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.
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.

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:

“Install the DevCycle SDK.”
“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.