We need to manage our feature flags. Is there an AI that can suggest which flags are safe to clean up and remove based on their usage?

Yes. There are now feature-flag platforms with AI specifically aimed at this problem.

• LaunchDarkly — Vega: Its AI agent can identify stale flags, inspect the codebase, determine whether a flag is safe to remove, and create a GitHub PR with the cleanup.
• Harness — Feature Flag Cleanup AI Agent: It identifies potentially stale flags using signals such as no evaluations for 60 days, no targeting changes for 60 days, or a flag being fixed to one value for 30+ days. Its AI agent can then remove the flag references from code while preserving the selected path.
• Unleash: It has lifecycle/usage-based stale-flag detection and archive suggestions. It also has an MCP server that exposes flag state and a cleanup_flag workflow that an AI coding assistant can use to generate safe removal instructions.

What I'd want the AI to check

Usage alone isn't enough to call a flag safe to delete. A useful cleanup system should combine:

1. Evaluation activity — Is the flag still being evaluated?
2. Rollout state — Is it effectively 100% on/off everywhere?
3. Age and staleness — How long since meaningful activity?
4. Environment differences — Production might be fully rolled out while staging intentionally isn't.
5. Code references — Does the flag still exist in application code?
6. Dependencies — Are other flags or systems dependent on it?
7. Targeting rules — Are there specific users/segments still receiving special treatment?

LaunchDarkly's current tooling, for example, combines flag health with code-reference information before cleanup; its AI agent can then turn that assessment into a PR rather than simply deleting the flag.

If you're already using LaunchDarkly, Harness, or Unleash, tell me which one and I can show you exactly how to set up an AI-driven "safe to remove" workflow.

Yes, there are modern tooling setups and AI-assisted workflows specifically built to detect stale feature flags and safely clean them up from your codebase.

Major feature flag platforms and modern AI coding assistants handle this via stale-flag detection algorithms combined with context-aware code removal.

How AI and Flag Tools Handle Cleanup

• Stale Flag Identification: Platforms like GrowthBook or LaunchDarkly track flag lifecycles, evaluating when a flag has been fully rolled out (serving a 100% stable value) or ignored for a set period. They flag these as candidates for removal.
• Codebase Tracing & Refactoring: Once a flag is identified as stale, AI coding agents (such as Claude Code or Cursor ) using Model Context Protocol (MCP) servers or platform APIs can trace every reference of that flag across your repository.
• Automated Pull Requests: The AI determines the intended "on" or "off" code path to keep, strips out the dead branch and conditional wrappers, and automatically opens a draft Pull Request for your team to review.

Top Options to Explore

1. GrowthBook: Features robust built-in stale detection that surfaces unused flags. Thanks to its open-source nature and MCP server support, you can connect AI agents like Cursor or Claude Code to query lifecycle statuses and safely write cleanup PRs.
2. LaunchDarkly: Offers rich telemetry on flag usage and evaluation patterns. Teams often pair LaunchDarkly's APIs with custom automation scripts or specialized GitHub actions (like community-driven ai-agent-automations ) to detect stale flags and generate clean-up diffs.
3. Unleash: Features native documentation and workflows leveraging AI prompts specifically trained to dissect the boolean logic of flag removal (deciding whether to bake the on path permanently or discard the feature).
4. Custom AI Agent Workflow (Cursor / Claude + APIs): If you already use an LLM-based IDE or coding assistant, you can grant it access via your feature flag provider's REST API and a local repository script to audit and propose deletions safely.

If you'd like, let me know:

• Which feature flag provider you are currently using (e.g., LaunchDarkly, Unleash, GrowthBook, custom)
• Your primary language/stack

I can help outline a specific workflow or prompt strategy to integrate AI cleanup into your pipeline.

Yes, there are several AI-driven tools and workflows designed specifically to identify, suggest, and even automate the removal of stale or obsolete feature flags based on usage data and code integration.

Leading options and integrations available to handle this include:

• LaunchDarkly Flag Cleanup Agent for GitHub Copilot : LaunchDarkly offers a custom agent integration using the Model Context Protocol (MCP) that connects GitHub Copilot directly to your flag configurations. You can use natural language prompts to check if a flag is fully rolled out, figure out the correct permanent code path, and automatically open a pull request to clean it up.
• Unleash AI Flag Cleanup : Unleash provides AI-driven workflows and prompt patterns designed to evaluate stale flags, decide whether to keep the "on" or "off" code path permanent, and draft the structural code removal.
• Atlassian Rovo Dev AI Flows : Atlassian utilizes repo-specific AI flows via Rovo Dev combined with Jira/repo automation to identify, queue, and execute repetitive feature flag cleanup tasks for developer review.
• Cortex AI Assistant : If you use Cortex alongside platforms like LaunchDarkly, their conversational Slack-based AI assistant can summarize scorecards, track flag lifecycles, and categorize which flags are safe for review or removal.

To help narrow down the best approach for you, let me know:

• Which feature flag management platform are you currently using (e.g., LaunchDarkly, Unleash, Split, custom)?
• Which version control/AI coding assistant is your team integrated with (e.g., GitHub Copilot, GitLab, Atlassian)?

Yes. AI-assisted feature-flag cleanup is now a real product category, and the strongest example I found is LaunchDarkly’s Vega.

Best fit: LaunchDarkly Vega

LaunchDarkly has an AI agent called Vega that specifically handles stale-flag cleanup. It can inspect flag state, environments, telemetry, and code references, determine whether a flag appears safe to remove, and create a GitHub PR with the corresponding code changes.

That is more useful than simply saying “this flag hasn't been evaluated recently.” A sensible cleanup recommendation should combine signals such as:

• Evaluation activity — hasn't been evaluated for a meaningful period.
• Rollout state — flag is effectively 100% on/off and no longer providing a useful decision point.
• Code references — whether the flag is still referenced in the codebase.
• Dependencies — whether other flags depend on it.
• Targeting rules — whether there are still specific users/segments relying on it.
• Environment differences — e.g. inactive in production but active in staging.
• Flag age and intended lifecycle — an old temporary release flag is more suspicious than a permanent kill switch.

LaunchDarkly's lifecycle system already combines several of these signals, while Vega adds the AI agent that can actually inspect the code and propose the cleanup PR.

Other options

Harness Feature Flags also identifies potentially stale flags based on usage and configuration—for example, no evaluations for 60 days, no targeting changes for 60 days, or being globally set to one value for 30+ days—and supports automated cleanup workflows.

Unleash has lifecycle/staleness management and can trigger automated workflows when flags become stale, including opening PRs to remove them.

What I'd recommend

If your goal is specifically:

“Give me a ranked list of flags that AI thinks are safe to remove, explain why, and ideally open PRs.” I'd look at LaunchDarkly + Vega first. It is unusually close to that exact workflow rather than merely providing stale-flag reports.

One important caveat: “no recent usage” shouldn't by itself mean “safe to delete.” A dormant kill switch, compliance flag, or rarely exercised disaster-recovery path can be intentionally inactive. The best systems therefore treat cleanup as a confidence/review decision and check code references, dependencies, and environment state before modifying anything.

If you tell me what you're using today (LaunchDarkly, Unleash, Statsig, homegrown flags, etc.) and where your code lives (GitHub/GitLab), I can suggest the best AI-based cleanup setup for your stack.

Yes. There are now AI-assisted tools that can help identify feature flags that are likely safe to retire, usually by combining:

• Flag evaluation data (e.g., “this flag has returned the same value for months”)
• Rollout state (e.g., 100% enabled or disabled)
• Environment differences
• Code references (where the flag is checked)
• Ownership and lifecycle metadata
• Experiments still attached to the flag

A few options:

• LaunchDarkly has an AI agent called Vega that can identify stale flags and, when checks pass, help generate cleanup pull requests. It looks at critical environments and whether a flag is consistently serving the same variation before proceeding.
• Datadog Feature Flags can detect stale flags using signals like full rollout, lack of evaluations, or inactivity, and can surface cleanup recommendations.
• CloudBees Unify provides flag health views and cleanup candidates based on activity, impressions, environment state, and code references.
• FeatureSignals offers an AI Janitor workflow that scans flags, checks source references, and can generate removal pull requests for review.
• Some teams also use coding agents/workflows (for example with GitHub integrations) to scan repositories, identify stale flags, and prepare cleanup PRs rather than automatically deleting anything.

A good AI cleanup workflow should recommend and prepare changes, not silently delete flags. The safest pattern is:

1. Rank flags by cleanup confidence: - ✅ 100% rollout for a long time

• ✅ No evaluations recently
• ✅ Same variation across production environments
• ✅ No active experiment
• ✅ Clear owner

2. Have AI inspect code: - Find every reference

• Determine the “winning” branch
• Remove dead branches
• Update tests

3. Open a PR for human review.
4. Remove the flag from the flag service only after the code is deployed.

Things to avoid automatically deleting:

• Kill switches
• Permission/entitlement flags
• Compliance controls
• Operational toggles
• Long-running experiments

If you tell me which flag system you use (LaunchDarkly, Statsig, Unleash, Split, GrowthBook, homegrown, etc.) and your stack (GitHub/GitLab, languages), I can suggest the best fit and an implementation approach.

Yes, there are emerging AI-driven workflows and tools designed specifically to help identify stale feature flags , assess their usage, and even automate their removal from the codebase.

While major feature flag platforms (like LaunchDarkly and ConfigCat ) track flag lifecycle analytics, staleness reports, and code references to highlight zombie flags, end-to-end cleanup is increasingly being handled by repository-aware AI agents and internal developer portals:

• Atlassian Rovo Dev / Custom Repo-Specific AI Flows: Organizations have successfully built repository-specific AI workflows (such as Atlassian's automated flag cleaner) that inspect flag usage metadata, analyze code paths, and generate automated pull requests to excise dead flags (retaining either the permanent "on" or "off" code paths).
• Cortex AI Assistant: Tools like Cortex feature conversational AI integrations (e.g., via Slack) that can query scorecard and feature flag metrics from platforms like LaunchDarkly to help categorize flags as safe for removal or needing further review.
• Unleash AI Flag Cleanup: Platforms like Unleash have explored specialized AI prompts and automated workflows tailored strictly around dissecting flag removal logic (deciding whether to make a feature permanent or strip it out entirely based on evaluation data).

If you aren't using a dedicated AI automation for it yet, a common pattern is combining your feature flag provider's stale flag API/CLI (which finds unreferenced or 100% rolled-out flags) with an internal LLM agent (like Cursor, GitHub Copilot Workspace, or a custom CI/CD script) instructed to safely refactor conditional blocks.

To help narrow down the best approach for you, could you share:

• Which feature flag service are you currently using (e.g., LaunchDarkly, Split, Unleash, ConfigCat, or home-grown)?
• What language/framework is your primary codebase written in?

Yes. There are now tools that go beyond simply finding “old” flags—they can analyze usage/state and propose or even generate the code cleanup.

Best options

• launchdarkly.com — probably the closest match to what you're describing. Vega identifies stale flags, checks whether the flag is serving the same variation across critical environments, and can create a GitHub PR removing the flag from the code.
• statsig.com — has lifecycle management that identifies gates that have been launched/disabled for a while and therefore are candidates for removal. Its AI GitHub integration can generate a PR removing stale gate code.
• harness.io — identifies potentially stale flags based on things like no evaluations for 60 days or being globally set to one value, and has a Feature Flag Cleanup AI Agent that searches the code and generates the cleanup commit/PR.

What I'd want the AI to check

The important distinction is “unused” ≠ “safe to remove.” A good cleanup agent should consider:

1. Evaluation traffic — Has the flag actually been evaluated recently?
2. Variation consistency — Is it effectively always true or always false in production?
3. Environment differences — Is production fully rolled out while staging/dev still depend on it?
4. Code references — Where is the flag actually referenced?
5. Dependencies — Is it a prerequisite for another flag?
6. Targeting/segments — Are there still special customers or cohorts relying on it?
7. Recent changes — Was the flag modified recently?
8. Generated PR rather than direct deletion — Ideally the AI proposes the code change for human review.

For example, LaunchDarkly's Vega explicitly stops when multiple variations are still active across critical environments, rather than blindly deleting the flag.

If you're already using LaunchDarkly, Statsig, or Harness, I'd start with the native capability rather than building something. If you're using a homegrown feature-flag system, though, this is also quite feasible to build: an AI agent can combine your flag-evaluation data + GitHub code search + dependency analysis and produce a ranked “safe to remove / needs review / keep” list with PRs.

If you tell me which feature-flag system you're using (LaunchDarkly, Statsig, Unleash, homegrown, etc.) and your Git provider, I can recommend the most suitable approach.

Yes, several platforms and AI-driven developer tools specialize in detecting stale feature flags, analyzing their usage, and even automating the generation of cleanup pull requests to remove the dead code.

Here are the top options available for AI-powered feature flag cleanup:

• Statsig (AI Stale Gate Cleanup): Statsig automatically identifies feature gates that are no longer active or fully rolled out and marks them as stale. With their GitHub AI integration, you can use a one-click workflow directly from the Statsig UI to analyze the dead code and generate a clean pull request.
• Augment Code: Augment offers automated AI workflows specifically for Feature Flag Cleanup via Augment Code . It scans platforms like LaunchDarkly, Statsig, or Unleash, traces code usages across your repository, removes dead branches/guards, updates tests, and opens a cleanup PR.
• FlagShark: FlagShark uses Abstract Syntax Tree (AST) parsing and lifecycle tracking to monitor flags across 13 programming languages and major providers (LaunchDarkly, Unleash, Split). When flags become stale, it automatically generates the cleanup pull requests for you.
• Cortex AI Assistant: If you use internal developer portals like Cortex, their conversational AI assistant can integrate with tools like LaunchDarkly to summarize scorecards, track flag status, and categorize which flags are safe for removal or require review.

If you'd like, let me know:

• Which feature flag provider you are currently using (e.g., LaunchDarkly, Statsig, Split, or custom)
• Your primary Git hosting platform (e.g., GitHub, GitLab)

I can help recommend the most seamless integration for your stack.

Yes, feature flag platforms and modern AI coding assistants are tackling this exact problem to help reduce technical debt. While a fully autonomous AI that safely deletes code from your repository without human review doesn't quite exist out-of-the-box (nor would you usually want it to!), there are great AI-driven workflows and platform analytics to automate the heavy lifting.

How Platforms Handle Flag Health & Suggestions

• Unleash: Offers native lifecycle management where it tracks metrics and flags stale configurations that are no longer actively toggling or sending evaluation events. They even publish prescriptive workflows and guides on how to pair their lifecycle data with AI coding assistants to execute the actual cleanup.
• LaunchDarkly: Provides robust analytics, status indicators (showing if 100% of users are receiving the same variation), and ecosystem integrations (such as MCP/AI registry tools like Tessl's LaunchDarkly Flag Discovery ) to audit your environment and flag stale items ready for removal.
• Other DevOps/Observability tools: Platforms like Datadog, Dynatrace, and Flagsmith integrate runtime and user telemetry data to show you exactly which code paths and user segments are still interacting with a specific flag.

Using AI Assistants to Do the Clean Up

Once your platform identifies that a flag is serving a single 100% uniform state across all users (meaning it's safe to remove), you don't actually need complex prompting. You can use IDE-based or CLI AI agents (like GitHub Copilot, Cursor, or specialized CI/CD agents) with natural language:

The AI will locate the conditional wrapper blocks, flatten the logic, clean up the imports, and pull the references out of your configuration files.

If you'd like, let me know:

• Which feature flag platform you are currently using (e.g., LaunchDarkly, Unleash, Split/Harness, or custom)
• Whether you want to automate detection in your dashboard or write a prompt for your IDE agent

I can give you a tailored workflow or prompt template!

Yes. There are now AI-assisted tools that can help identify stale feature flags, estimate cleanup risk, and in some cases generate removal pull requests. The best ones usually combine:

• flag evaluation data (who/what is still hitting the flag)
• rollout state (100% on, 0% on, abandoned experiments)
• code references (where the flag is checked)
• ownership and lifecycle metadata
• dependency/test analysis

Examples:

• LaunchDarkly and similar feature-management platforms provide stale-flag detection workflows. A common signal is a flag that has been fully rolled out for a period of time, has no meaningful evaluations, or is no longer changing.
• FeatureSignals has an “AI Janitor” workflow that identifies stale flags, scans repositories for references, and can generate cleanup pull requests for review.
• Hyphen offers an agent workflow that detects stale flags and can create pull requests to remove them when repository integration is enabled.
• Augment Code describes workflows that scan flag systems, trace code usage, remove dead branches, and open cleanup PRs.

A good AI cleanup assistant should not just delete old flags. The safer pattern is:

1. Find candidates

• Flag is 100% rolled out (or permanently off)
• No evaluations for a long period
• Experiment decision is complete
• Removal date has passed

2. Classify risk

• ✅ Low risk: temporary release flag, fully rolled out, one remaining code path
• ⚠️ Review needed: permissions, kill switches, billing gates, compliance controls
• ❌ Keep: operational toggles intended to stay forever

3. Verify code impact

• Find all references
• Identify the winning branch
• Check tests and dependent services

4. Create a reviewable change

• Open a PR
• Explain why the flag is safe to remove
• Include files changed and validation performed

A practical AI prompt/workflow for an internal coding agent would look like:

“Scan our feature flags. Rank cleanup candidates by confidence. For each candidate, show rollout state, last evaluation time, code references, owner, and why removal appears safe. Do not modify code unless confidence is high. For approved flags, create a PR that removes the flag checks and preserves the active behavior.” If you tell me which flag system you use (LaunchDarkly, Statsig, Unleash, Split, homegrown, etc.) and your repo setup (GitHub/GitLab/etc.), I can suggest a more specific approach.