Agentic feature flags

·‎

Sep 22, 2025

·‎

‎min read

·‎

Rasmus

As coding agents mature and developer adoption accelerates, organizations can produce code faster than ever. But with speed and agent-written code comes risk and merge conflicts.

To unlock shipping fast – and safely – mitigating these issues is essential.

Agent-ready feature flags make this possible.

AI is transforming code production in two key ways:

Assisted coding (inner loop) — Tools like Cursor boost developer productivity, enabling engineers to generate more pull requests each week. Assisted coding has been the norm for over a year, helping engineers move faster while retaining human oversight.

Coding agents (outer loop) — Assigning issues directly to agents (e.g. via Linear) allows engineers to work on multiple features simultaneously. It also extends code production beyond engineers—PMs and customer success teams can now convert feedback into shipped features through agent-generated PRs. While these PRs still undergo human review, agent-authored code carries higher risk of bugs or unintended consequences.

With integrations like “Assign to Cursor” on Linear, even non-engineers can trigger product updates, and this shift is already happening!

25% of all Linear workspaces now use agents — most of them coding agents — and adoption is even higher among enterprises, where 50% are already on board.

Karri Saarinen, Linear’s co-founder, posted last week:

25% of Linear workspaces now use agents and 50% in enterprise.

Mainly it’s Cursor, Devin & Codegen coding agents, directly tasked from @linear to fix bugs and improvements.

‍

And then quoted a Linear user:

We turned it on a few days ago and now people in customer success and sales are throwing up too many PRs for us to review. It’s been pretty great at burning down small issues that we keep putting off.

Move faster with flags

The rise of assisted coding and coding agents means organizations will soon see a dramatic surge in pull requests.

It's a huge leap forward, but also introduces new bottlenecks and risks:

Engineers spending significantly more time on code reviews
More merge conflicts as multiple changes are in flight
Higher likelihood of bugs or unintended side effects in agent-authored PRs

Feature flags directly address the last two challenges.

Solving merge conflicts with flags

Merge conflicts can slow teams down. By having agents work on small, incremental changes, code can be merged into main quickly and safely behind a feature flag, avoiding long-lived branches that create painful conflicts.

This approach enables trunk-based development: Frequent merges without exposing unfinished work to customers. The result is a unified codebase, full test coverage across the application, and the elimination of the drag caused by long-lived branches.

De-risking agent-coded features

Moving fast isn’t just about generating code quickly — it’s about getting it safely shipped to production.

With coding agents producing more PRs, engineering teams risk becoming bottlenecked by tons of code reviews and local testing.

Feature flags shift this dynamic. Engineers can review, merge, and deploy flagged code faster, knowing they always have the safety net of turning features off in production if regressions appear.

Flags also help distribute the testing workload. Engineers can release features internally, enabling the non-engineer who assigned the task to an agent – to test and validate the changes in production before releasing it to any customers.

How Reflag works with coding agents

Reflag is agent-ready and slots perfectly into an autonomous coding agent workflow. Here’s how it works, step-by-step.

In this example we’ll use the Cursor agent on Linear:

Team member drafts issue with product improvement specification.
Team member assigns issue to Cursor Agent.
Cursor Agent starts working on the issue in a new branch.
Team member provides Cursor Agent with flag key using Reflag’s Linear agent, or the Agent creates it automatically using Reflag’s MCP / CLI.
Cursor Agent publishes pull request for review.
Human reviews and merges pull request.
Human uses Reflag to gradually release the feature – from internal testing to external customers.
When the feature has been released to everyone, Reflag detects it automatically and the built-in Reflag agent creates a new branch and removes the feature flag.
Human reviews and merges clean-up pull request.

1. Team member drafts issue with product improvement specification.
2. Team member assigns issue to Cursor Agent.
3. Cursor Agent starts working on the issue in a new branch.
4. Team member provides Cursor Agent with flag key using Reflag’s Linear agent, or the Agent creates it automatically using Reflag’s MCP / CLI.
5. Cursor Agent publishes pull request for review.
6. Human reviews and merges pull request.
7. Human uses Reflag to gradually release the feature – from internal testing to external customers.
8. When the feature has been released to everyone, Reflag detects it automatically and the built-in Reflag agent creates a new branch and removes the feature flag.
9. Human reviews and merges clean-up pull request.

You can either let Cursor know in the issue description to feature flag the feature with Reflag, or you can create a Cursor rule to let Cursor know to always use Reflag for feature flagging.

See it in action → reflag.com/agents