Meet us at AWS re:Invent and learn to automate your releases - Booth 1645 — Learn more

Skip to:
BlogEngineering
Review the release plan alongside the code

Nov 20, 2026

Review the release plan alongside the code

When coding agents open more of your pull requests, the release decision has to happen where you already review the code. This post follows one agent-written change to an interior design app and shows how its release plan gets proposed, reviewed, and approved on the pull request.

Alexis Roberson
Senior Developer Educator

Code review has rarely included the release plan. You read the modified files, confirm the change does what the pull request asserts, and approve it. The decisions about exposure get made later: by someone else, by whatever the pipeline does by default, or by no one. Then every user gets the change at once. 

Those decisions make up the release plan: whether the change ships behind a feature flag, which environments receive it and in what order, and how each environment exposes the new behavior after the code is running there. That handoff leaves you, the person who understands the implementation, out of the decision about how it reaches users. When the release plan appears alongside the code, you can review both in the same pass.

LaunchDarkly Release Autopilot puts that plan in the pull request. Your release plans set the default, and review is where you check whether this change fits them. This post follows one pull request a coding agent opened against an interior design app. The change leans on a new inventory service, and each part of the plan raises a question to answer before you approve it.

The recommendation arrives with the code change

A coding agent opens a pull request that adds every product the agent saves to the shopper's cart, swaps in an in-stock item when the original is out of stock, and calls a new inventory service on each save. The modified files cover the cart, inventory check, cart routes, and their tests, and the tests pass. By the usual standard, you could approve it. What the tests can't tell you is what happens to every shopper's cart if that inventory service slows down or fails once the code is deployed.

Release Autopilot brings this question into the review. When the pull request is marked ready for review, it posts a recommendation with three parts: whether the change needs a flag and why, the flag it proposes, and a release plan by environment. Each part answers a piece of that question, so read them in order.

Check the recommendation before the flag

The first question is whether the change needs a flag at all. Release Autopilot classifies each change before it proposes a flag, and some changes don't get one.

For the cart change, the comment leads with "Feature flag recommended" and a suggested release. The change writes to every user's cart each time the agent saves a product, calls a new inventory service, puts substitutes on the list shoppers approve, and opens cart actions to users who had the cart turned off.

Read those reasons against the code change you just reviewed. If they describe a different change, the recommendation rests on a misreading, and the flag and plan that follow inherit it. If they name the same risk you noticed, the rest of the plan was at least built for the right problem.

When you think the recommendation is wrong, or when the reasons match, say so on the pull request. These commands are part of auto-flagging, which is in beta, so their behavior may change.

  • @launchdarkly reject rejects the current proposal.
  • @launchdarkly feedback inaccurate records your rating of the analysis. You can follow it with a note, for example, @launchdarkly feedback inaccurate this change only touches test fixtures.
  • @launchdarkly replan discards the current proposal and starts a new analysis. You can add text after the command to give the new analysis context.
  • @launchdarkly feedback accurate records your rating that the analysis was accurate. You can follow it with a note.

Either feedback command records how Release Autopilot did on the pull request. That's worth the extra comment when agents are opening more of the pull requests you review. For every command Release Autopilot supports, see the Release Autopilot FAQ.

Read the flag commit the way you read the agent's code

After you agree the cart change needs a flag, you comment @launchdarkly approve flag on the pull request. Release Autopilot creates a flag named decor-cart-autofill in LaunchDarkly, off in every environment, and pushes a new commit to the same pull request that wraps the agent's new cart behavior in an evaluation of that flag. The automatic cart fill, in-stock substitution, commit swap, linked cart removal, and relaxed cart actions now all sit behind decor-cart-autofill. 

You didn't write that commit, and neither did the agent whose code change you just reviewed, so it's easy to treat it as plumbing and move on. That commit decides which parts of the change you can turn off later, so give it the same read you gave the agent's code. If the inventory service starts failing after you deploy, this commit determines whether turning off one flag stops all five behaviors or leaves some of them running.

Start by checking that the flag wraps only those five behaviors. If it wraps more, turning it off during an inventory failure also turns off code that was working fine. Then confirm that the existing path still runs when the flag is off. 

Here, add_spec only fills the cart when the flag evaluates to true, and the flag defaults to False. Saving a product therefore leaves the cart alone, and the cart stays hidden for users without cart hold. That path is what shoppers receive until the release starts, and it's what they return to if the release rolls back.

Finally, look at whether the tests exercise both paths, so the old code isn't running against the new tests for the first time on the day someone turns the flag off.

Approving the flag and approving the release are separate decisions. After the flag commit, Release Autopilot hasn't configured a release yet, so you can review the commit before you sign off on the plan with @launchdarkly approve release.

Judge the plan against what the change could break

The release plan puts two questions in front of you. The first is whether the environment suits this change. For the cart change, the plan releases to Test first, then runs a guarded release in Production at 5%, 10%, 25%, and 50% for an hour each. For most changes that's reasonable. This one writes to carts on every save, so 5% of shoppers is still a lot of carts if the inventory service fails in the first hour. 

That's the reason to ask for a smaller start. On this pull request, @launchdarkly refine asked for 1% instead of 5%, and the reply explained that the 5% stage comes from the project's shared guarded release plan, so changing it would affect every flag that uses that plan. A smaller start would need its own plan, followed by @launchdarkly replan. That makes stage size a decision for the team's release plans, while the review settles whether this change fits them.

Make sure Production watches the right signals

The second question is whether Production will watch the right signals. A guarded rollout monitors only the metrics attached to the flag. A release in an environment without a guarded rollout, or with no metrics attached, moves through its stages without regression checks. 

For the cart change, the app now sends a request error event when the inventory call fails, so check whether the plan attaches a metric built on that event. If it doesn't, the guarded release in Production won't notice the new service failing. 

When the attached metrics match what the change could break, and automatic rollback is turned on, LaunchDarkly can roll back the release on a regression while the rest of the deploy keeps running. When they don't match, the rollout can report a healthy release for a change that is failing in exactly the way you were worried about during review.

Three approvals, one conversation

Code review earned its place in the workflow by moving judgment to where a change is cheapest to correct. The release plan belongs at that same point.  Your CI/CD pipeline already automates how code gets deployed. Release Autopilot automates how a change reaches users: how it’s controlled, measured, and rolled out, and what happens when it degrades. That’s control by default, for every change you ship.  You have just reviewed the cart change, so you're the person best placed to decide whether it needs a flag, which environments should see it first, and which numbers would show the inventory service failing.

Approving the pull request settles whether the implementation is ready. Approving the flag settles which code the release controls, and approving the release settles how it reaches users and which guardrails watch it. All three decisions now happen in the same conversation, and the recommendation, your feedback, and any refinement stay on the pull request for the next person who needs to know why the change shipped the way it did.

To try it on your own pull requests, follow the Release Autopilot setup guide to install the GitHub app, connect a repository to a LaunchDarkly project, and choose your model provider.

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.