Introducing Release Autopilot: Automated release control for AI-built code — Read the announcement

Skip to:
BlogAI Agents
The safest release workflow is the one engineers don't have to remember

Nov 17, 2026

The safest release workflow is the one engineers don't have to remember

As AI agents write more code, release safeguards that depend on someone remembering to add them often get skipped. Here’s how to find those gaps and close them.

Alexis Roberson
Senior Developer Educator

Putting a change behind a feature flag sounds like a small addition to a pull request. In practice, an engineer has to instrument the code, configure the flag, choose an exposure strategy, identify what to monitor, and plan for cleanup. Each step serves a purpose, but the work adds up when engineers have to initiate it separately for every change that needs those controls.

Before doing any of that work, engineers have to decide whether the change needs a flag in the first place. That assessment is part of release preparation, which determines how a change should reach users and what safeguards it requires. A low-risk change may be ready for immediate exposure, while other changes need a rollout plan that includes monitoring and conditions for intervening.

Teams can document this process in detail and still struggle to apply it consistently. As AI agents produce more code changes, the number of release decisions and configuration tasks grows with them. Platform teams need a way to automatically incorporate appropriate safeguards into the development workflow while preserving engineering judgment over how each change should reach users.

What goes into preparing a flagged release?

Adding a feature flag starts with deciding which behavior to control. The engineer must identify the relevant execution paths, add flag evaluations, and establish what happens when the flag is disabled. The placement matters because the flag needs to isolate the intended behavior without disrupting functionality that should remain available.

Then comes configuration. The flag needs an initial state in each relevant environment, along with any targeting rules that determine who receives the new behavior. Those decisions affect what happens when the code reaches production, so they need to reflect the purpose of the change.

The engineer also needs to decide how the change should be released. Some changes can be enabled immediately for their intended audience. Others need gradual exposure, closer monitoring, or explicit conditions for stopping the rollout. That means identifying the production metrics that matter and deciding what results would justify expanding or reversing exposure.

Finally, temporary flags need to be removed. After a rollout is complete and the new behavior becomes permanent, leaving the flag and its code references in place adds configuration and conditional logic that future engineers have to maintain.

These decisions span different tools and stages of development. A pull request can pass review while its rollout strategy, monitoring requirements, and cleanup responsibilities remain undecided.

What happens when safeguards depend on someone remembering to add them

Release guidelines may explain how to complete each of those tasks, but someone still has to initiate the work. For a routine change on a busy day, that’s the step that slips.

Some changes receive the appropriate safeguards because engineers complete the additional preparation. Others proceed without a flag because someone assessed the risk and determined that immediate exposure was appropriate. Still others reach production without the recommended controls because the assessment or preparation never happened.

Recording the release decision allows teams to distinguish an intentional release strategy from an accidentally omitted assessment. Without that record, they can't reliably determine why a change reached production without additional controls.

The risk of unintentionally skipped safeguards grows as agents do more of the work. Agents can now write a change, test it, and open a pull request on their own, but decisions about who sees the change, what to watch, and how to undo it still wait for a person who is struggling to keep up.

Audit what happens to ordinary changes

To understand how often release preparation gets missed, teams need to look at what happened to ordinary changes after review. The release history should help establish which safeguards were applied, which were deliberately ruled out, and which decisions were never recorded.

A small audit of recently shipped pull requests provides a way to investigate those differences and identify where the workflow needs attention.

Step 1: Select ordinary changes

Start with approximately 10 recently shipped pull requests across a few repositories or services.

Choose routine feature work and maintenance changes that went through the team's standard review process. Include changes with different levels of complexity, but avoid building the entire sample around major launches or production incidents, which often receive additional coordination.

The goal is to understand the release process engineers follow during ordinary development. Ten pull requests give you a manageable starting point. Expand the sample after you know which gaps to look for.

Step 2: Determine which safeguards should have applied

For each change, compare its purpose and potential impact with the release standards the team had in place at the time.

Was a release-risk assessment required? Did the change warrant a feature flag or another exposure control? Should engineers have selected production metrics, established rollback conditions, or created a cleanup task?

The answers will differ between changes. A routine update with limited impact may need little additional control, while a change affecting shared infrastructure or critical application behavior could justify a more cautious release.

Evaluate each change against the safeguards appropriate to its purpose and risk.

Step 3: Trace what actually happened

Follow each change from pull request review through deployment and release.

Start with the pull request. Look for evidence that someone considered how the change should reach users. Then examine any associated flag configuration, targeting rules, rollout history, monitoring records, and follow-up tasks.

The goal is to reconstruct the release decision from the available evidence.

A change might have a feature flag but no documented reason for its initial targeting. Another might have a clear rollout strategy but no metrics selected to evaluate its effect. A temporary flag might have been introduced without an owner for its eventual removal.

Record what happened and where the evidence is located. This makes the findings useful to the engineers responsible for improving the workflow.

Step 4: Classify the findings

For each safeguard evaluated against the team's release standards, assign one of five outcomes:

Outcome

What it means

Completed

The safeguard was applied.

Explicitly judged unnecessary

The team assessed the change and documented why a safeguard wasn't needed.

Skipped

The safeguard was applicable but wasn't added.

Unable to verify

The available records don't establish what happened.

Not applicable

The safeguard wasn't relevant to the change or its release approach (i.e., flag cleanup for a change with no flag).

A change deliberately shipped without a flag can represent a sound release decision, but if there's no record of an assessment, the team can’t reliably reconstruct why it chose that approach. Missing documentation doesn't establish that an engineer failed to consider the risk, but it does reveal a gap in the release record.

A simple worksheet keeps the results comparable. Give each pull request its own row, and each safeguard its own column, then record one of the five outcomes in each cell, along with a link to the evidence.

Pull request

Risk assessment

Exposure control

Monitoring and response criteria

Cleanup ownership

PR 1

Completed

Explicitly judged unnecessary

Explicitly judged unnecessary

Not applicable

PR 2

Unable to verify

Completed

Skipped

Skipped

PR 3

Completed

Completed

Completed

Unable to verify

Reading down a column shows where safeguards were skipped or decisions couldn't be verified. Reading across a row shows which parts of the release process were documented for a particular change.

When comparing how often safeguards were missed, exclude those marked Not applicable because they represent controls that weren't relevant to the change.

Step 5: Identify the recurring gaps

Compare the results across the sample and look for safeguards that repeatedly require follow-up or go unfinished. Then, summarize which gaps recur, what risks they introduce, and where additional manual coordination contributes to the problem.

Frequency matters, but consequences matter, too. A safeguard skipped occasionally on a high-impact change may deserve attention before a more common omission with limited operational effect.

Choose one or two gaps that occur frequently or carry the highest consequences. For each, identify where in the workflow it should be addressed and who should approve the result.

4 safeguards worth building into the normal workflow

The audit shows which safeguards your team skips most often. Instead of adding another step for engineers to remember, build those safeguards into the workflow so they happen by default. Engineers still approve the result, because automation can misread a change or suggest the wrong controls.

1. Make release-risk assessment part of every change

If the audit finds pull requests with no recorded release decision, make the assessment automatic. It should consider what the change affects, how widely its behavior will be exposed, and the consequences of failure. 

The reviewer confirms or overrides the assessment. For some changes, the answer will be an immediate release with minimal controls. Others will need a gradual rollout and monitoring. Either way, the decision is recorded by default, so no one has to reconstruct it later.

2. Prepare feature flag controls when appropriate

Sometimes an engineer knows a change should go behind a flag but never gets around to setting it up. The fix is to have the workflow propose the flag during code review: where it goes in the code, who sees the change first, and how quickly it rolls out to everyone else. The engineer checks the proposal, adjusts it, and approves it.

3. Include monitoring and response criteria in release preparation

If the audit finds releases without agreed-upon monitoring or response criteria, incorporate those decisions into release preparation automatically. 

For changes that warrant closer monitoring, the workflow can propose metrics that reflect the change's intended outcome, along with the thresholds that would pause or reverse the rollout. 

Engineers review and adjust those criteria before exposure begins. After they’re approved, they give the workflow an agreed-upon basis for pausing or reversing the rollout, instead of leaving that call to whoever happens to notice a problem.

4. Account for temporary safeguards through cleanup

If the audit finds temporary flags without cleanup owners, don't rely on someone remembering to remove them. Create the cleanup task automatically when the flag is introduced, assign it to the change's author, and trigger it when the rollout completes. The engineer reviews and merges the removal like any other pull request.

Make the safest path part of the normal workflow

When engineers look back at an ordinary release, they should be able to reconstruct why the team chose its exposure strategy and which safeguards were expected to apply. The audit reveals where those decisions are missing from the release record and which parts of the process need attention.

Engineers retain control over how changes reach users, and routine releases receive the safeguards their risks call for without requiring someone to initiate a separate process each time.

Flaming pointer icon
Get started in minutes.

Learn how to scale seamlessly with LaunchDarkly as your project grows.

Letter in envelope icon
Sign up for our newsletter.

Get all the content, tips, and news you can use.

By supplying my contact information, I authorize LaunchDarkly to contact me with personalized marketing communications about our products and services. See our Privacy Policy for more details, or Opt-Out at any time.