Best practices for shipping software safely using AI

AI can make software teams feel faster before the release system is actually safer. A developer can generate an implementation, a test file, a migration, a pull request description, and release notes in one sitting. That is useful. It also means the old bottlenecks move downstream: review, QA, security, observability, rollout ownership, and rollback planning all get compressed into a smaller window.
The best practices for shipping software safely using AI are not about slowing the team back down. They are about making the release path explicit enough that faster coding does not turn into uncontrolled production exposure.
For product and engineering teams, the core question is simple: if AI helps create the change, what keeps the release accountable? The answer is a stack of ordinary software delivery practices applied with more discipline: scoped tasks, human review, feature flags, staged rollouts, evals, guardrail metrics, and cleanup criteria.
Treat AI as a release accelerator, not a release owner
The most dangerous AI release workflow is the one that lets code generation blur ownership. AI can draft, refactor, summarize, test, and inspect. It cannot own the business context, the user risk, or the production decision.
That distinction should be visible in the workflow. Before an AI-assisted change moves toward production, the team should know who owns the requirement, who owns the code, who approves exposure, and who will respond if a rollout goes wrong. If those responsibilities are unclear, the team is not ready to ship even if the implementation compiles.
This matches the broader direction in NIST's secure software development practices for generative AI, which extends secure development practices to AI systems rather than treating AI as a separate universe. AI-assisted software still needs secure design, review, testing, provenance, and operational controls.
Community discussions reach the same point from the other side. Engineers on Hacker News and Reddit often disagree about how much AI speeds coding itself, but the practical concern is consistent: faster code generation does not automatically remove requirements, review, QA, or deployment work.
The release policy should make that explicit:
ai_assisted_release:
owner: engineering
required_checks:
- human_code_review
- security_review_for_sensitive_paths
- flag_off_test
- flag_on_test
- rollout_guardrails
default_exposure: internal_only
rollback: feature_flag_offThat kind of small contract is not bureaucracy. It is how the team keeps AI in the role where it is strongest: accelerating work that humans still understand and own.
Scope the task before the agent writes code
AI tools perform better when the task has clear boundaries. "Build the new onboarding flow" is not a release-safe prompt. "Add the new onboarding checklist behind the onboarding-checklist-v2 flag, preserve the current path as fallback, instrument completion events, and add tests for flag-off and flag-on states" gives the agent a release-aware shape.
The difference is not just prompt quality. It changes what reviewers get back. A scoped AI task can be inspected against a checklist. An open-ended AI task often creates hidden decisions that reviewers have to discover after the fact.
Good AI release tasks define:
- The user or account segment affected.
- The GrowthBook flag or experiment that will control exposure.
- The fallback behavior when the flag is off.
- The files or modules the agent should touch.
- The events, logs, or metrics that should prove the change is working.
- The tests that must pass before the pull request is considered reviewable.
This is where GrowthBook's AI-native development platform matters. The useful idea is not "let an agent ship for you." It is "bring the agent into the same release controls the team already uses." If the AI tool can create or inspect flags, experiment specs, and rollout rules, it can work against real release objects instead of inventing an implementation in isolation.
For teams using the GrowthBook MCP server, that means an agent can help find or create the flag that controls a change, then write code against that known object. The human reviewer still owns the decision to merge, expose, and expand.
Put AI-assisted changes behind reversible controls
AI increases the number of plausible changes a team can make. That makes reversible release controls more important, not less.
Feature flags are the practical foundation because they separate deployment from exposure. GrowthBook's feature flag docs describe the core pattern: control application behavior without deploying new code, target users, roll out gradually, or run experiments. For AI-assisted software delivery, this turns the release from a binary deploy into a controlled exposure sequence.
The Google SRE workbook on canarying releases frames the release problem as exposing a change to a small portion of real traffic before broad rollout. That idea becomes more valuable when the implementation was AI-assisted because the team may have moved faster than its normal manual discovery process.
There are three useful levels of control:
| Control | What it protects | Example |
|---|---|---|
| Flag-off fallback | Users can return to the known-good behavior | Existing checkout flow remains active when the AI-assisted path is off |
| Targeted exposure | Early users are chosen deliberately | Employees, beta accounts, one region, or one plan tier |
| Guardrail monitoring | Rollout stops when health degrades | Error rate, latency, support contacts, or conversion regressions |
GrowthBook feature rules support forced values, percentage rollouts, experiments, and Safe Rollouts. The important release habit is deciding which rule type matches the risk. Internal testing may use a forced value. A low-risk UI improvement may use a manual percentage rollout. A user-facing workflow change may need a Safe Rollout or an experiment.
For teams that want automated monitoring, Safe Rollouts release a feature to a subset of users while watching guardrail metrics for regressions. That is a better default than hoping someone notices a dashboard after the rollout has already reached most users.
Review AI-assisted code for the risks AI is likely to miss
AI-generated code can be syntactically polished while still missing the thing that matters. It may skip authorization checks, choose an unsafe dependency, misunderstand a business rule, under-test the fallback path, or add a clever abstraction that nobody wants to maintain.
The review process should be specific to those failure modes. A generic code review that asks "does this look right?" is too weak for an AI-assisted release.
At minimum, reviewers should check:
- Does the change match the requirement, or did the agent solve a neighboring problem?
- Is the fallback behavior still working and tested?
- Are all sensitive paths covered by authentication, authorization, input validation, and logging?
- Did the agent add or update dependencies, generated files, migrations, or background jobs?
- Are error states observable, or will failures disappear into logs nobody reads?
- Does the code keep the feature flag boundary clean enough to remove later?
- Did the tests cover both flag states and the most likely user edge cases?
Security deserves its own pass. OWASP's Top 10 for Large Language Model Applications and AI Agent Security Cheat Sheet are useful reminders that AI features and AI-assisted workflows introduce risks around prompt injection, tool permissions, data leakage, and over-trusted automation. Those risks do not replace normal application security; they sit on top of it.
This is also where AI can help the reviewer. Ask the agent to produce a release-risk review after implementation, but treat the output as a checklist, not a verdict. A useful prompt is:
Review this AI-assisted change for release risk.
Focus on flag boundaries, fallback behavior, tests, authorization, observability,
dependencies, data access, and cleanup work.
Return only concrete issues and the files or functions where they appear.The reviewer still decides what is real. The agent helps search the space.
Measure release safety and user value separately
One of the easiest mistakes in AI-assisted delivery is treating "the release did not break" as proof that the change helped. Those are different questions.
Release safety asks whether the change can expand without hurting system health or user trust. Product value asks whether the change improves a user outcome. Teams need both.
Guardrail metrics should catch harm early:
- Error rate and exception volume.
- p95 or p99 latency.
- Support contact rate.
- Checkout, signup, or activation regressions.
- API cost or infrastructure cost.
- Rollback frequency.
- Segment-level issues hidden by aggregate metrics.
Outcome metrics should prove value:
- Task completion.
- Activation.
- Retention.
- Conversion.
- Expansion.
- Revenue impact.
- Time saved in the workflow.
If the change affects AI behavior directly, add quality measures too. The OpenAI evaluation best practices guide is useful because it emphasizes task-specific eval design. Do not measure an AI support assistant with a generic benchmark if the real failure mode is whether users get a useful answer without opening a ticket.
GrowthBook feature flag experiments connect the release control to the measurement layer. A feature can start as a guarded rollout and become an experiment when the team needs evidence that the new behavior is better, not merely safe enough to expose.
Keep release artifacts inspectable
AI-assisted releases should leave a trail that another human can understand. That trail does not need to be heavy, but it should answer the questions people ask during incidents and post-launch reviews.
For each meaningful AI-assisted release, keep:
- The feature flag key.
- The rollout or experiment rule.
- The owner.
- The fallback behavior.
- The primary metric and guardrails.
- The human reviewer.
- The cleanup condition.
- The decision record after rollout or experiment analysis.
This protects the team from two common failure modes. The first is the mystery flag: a conditional path nobody wants to remove because nobody remembers why it exists. The second is the mystery win: a change that shipped, looked fine, and became permanent without anyone documenting what actually improved.
The OpenFeature evaluation context specification is helpful here because it separates the evaluated user or request context from the flag decision. In practice, that means teams should log enough context to know which users were exposed, which variant they received, and which release rule produced the result.
The practitioner warning is familiar: feature flags reduce release risk, but unmanaged flags become debt. Discussions on Hacker News and Reddit repeatedly come back to cleanup and test coverage. AI-assisted shipping makes that more urgent because it can create more flagged paths faster than the team is used to retiring them.
Build the minimum safe AI release loop
The safe starting point is smaller than most teams think. You do not need a perfect AI governance program before shipping one AI-assisted change. You do need a loop that keeps speed connected to control.
A minimum safe loop looks like this:
- Define the task and the release owner.
- Create or identify the GrowthBook flag before implementation.
- Ask the agent to implement against that flag and fallback.
- Review the code, tests, security, and observability.
- Deploy with the feature off by default.
- Expose internally first.
- Expand with a percentage rollout, Safe Rollout, or experiment.
- Decide based on guardrails and outcome metrics.
- Remove stale flags or losing variants after the decision.
The important part is sequencing. Do not generate the code first and decide how to release it later. That is how teams end up with a fast implementation and a risky launch. Put the release path into the task before the agent starts.
GrowthBook is useful here because feature flags, experimentation, targeting rules, Safe Rollouts, and agent workflows can sit in the same operating model. The agent can help create and inspect release objects, but the team still owns the exposure decision.
What to do next
Pick one upcoming AI-assisted change and run it through the full loop. It should be real enough to matter, but not so high-risk that the first test becomes a governance project.
Good candidates include:
- A new AI-generated summary in an internal workflow.
- A recommendation or ranking tweak behind an existing flag.
- A support or onboarding helper with a deterministic fallback.
- A refactor generated by AI where the visible behavior should not change.
- A narrow UI workflow that can be exposed to employees first.
The point is to practice the release system, not to prove that AI can write code. AI can already help teams write more code. The advantage goes to teams that can review, expose, measure, and roll back that code without losing control of the product.
Safe AI-assisted shipping is not a separate process. It is disciplined software delivery with a faster implementation engine plugged into it. Keep the human owner, keep the flag boundary, keep the metrics, and keep the rollback path close. That is how AI becomes a release advantage instead of a production liability.
Related Articles
A magazine's home page shows two recent issues. The design team wants subscribers to try a shelf with four. All four covers are public, and changing editions while the page is open should update the shelf immediately. That gives you a small React feature with a useful acceptance test. Click from guest to subscriber and back, and count the covers each time.
We'll put the display limit in a typed local flag, evaluate it inside a React component, and leave the choice of edition with the app. The example runs in a client-rendered React app without a GrowthBook account, an SDK key, or a request for flag rules. For the wider workflow, free feature flags for coding agents explains what to ask an agent to implement and how to review the result.
Define what one flag controls
Start with an existing React and TypeScript app, or create a Vite React project for the example. Install both GrowthBook packages so the definitions and the hooks resolve against compatible SDK versions.
Create src/flags.ts. Here the feature value is a number, which lets the component use the same rendering code for either edition. A future change from four covers to three is one edit to the rule.
A guest falls through to the default of two. A subscriber matches the rule and gets four. This rule applies to every subscriber, so the ID has no effect on the result here. If you later roll the shelf out to a percentage of subscribers, you already have an identity to use for repeatable assignment.
The type registration release note explains the version requirement for LocalFeatures. The registration connects the definition, the attributes, and the value returned by the hook. For the TypeScript mechanics, see Jeremy Dorn's Register pattern walkthrough.
Put the current reader above the shelf
Replace src/App.tsx with the component below. The edition switch is a local fixture so anyone reviewing the change can reproduce both states. In an existing app, take those two values from the active reader in your session layer.
The provider receives an instance initialized with the current reader and the checked-in rules. React can render the correct shelf on the first pass for that reader. If the app is still loading a session, decide what should occupy the shelf in the meantime. For this public list a two-cover guest view is reasonable. On a page where a switch would interrupt the reader, wait for the session before mounting the shelf.
Give your agent the React setup
Use the local flags guide to ask for a typed definition, a provider with the current reader, and a test that changes the edition.
Open the Agent GuideThe useMemo dependencies include the ID and the edition. If a reader subscribes while signed in, their ID can stay the same while their edition changes. Depending only on the ID would leave the old SDK instance in place. Passing a fresh object as the dependency on every render would create unnecessary instances. The example uses the two primitive values the rule setup actually needs.
Read the numeric flag where React renders the list
Create src/IssueShelf.tsx. Keep one stable ID per issue and let the component use the resolved value to select how many items to render.
Keep the hook at the top of the component, inside the provider's subtree. The React SDK supplies the flag value through that provider. Calling a hook inside a click handler or inside the list loop would break the Rules of Hooks. Use the returned number in ordinary render logic.
There are two places you can see the number two in this implementation. The definition's defaultValue is what an ordinary guest gets through evaluation. The 2 passed to the hook is a fallback for a value the SDK can't supply. Giving them the same value makes the basic shelf a sensible fallback, but checking only the guest case would let a broken provider arrangement or missing definition go unnoticed. The subscriber case proves that the component actually received the rule.
The list keys identify magazine issues. Keep those keys independent of the flag. Switching from two covers to four should preserve the identity of the first two rows. There's also no need to remount the whole app with an edition-specific key. React preserves state according to component position and keys. For example, a search input outside the shelf shouldn't lose its text because someone subscribed.
Check the transition in both directions
Use the template's build script to type-check and bundle the app. Once that passes, start the dev server and open the local address it prints.
On first load, the page says guest and lists November and October. Click Switch edition. The same page should say subscriber and add September and August. Click again. The list should return to the original two issues, in order. This last check catches code that appends more results on upgrade and never removes them on downgrade.
For a compile-time check, temporarily replace the numeric fallback with the string "2". Run the build again and inspect the error on the hook call. Then restore 2 and rebuild. If the string compiles, check that src/flags.ts belongs to the same TypeScript project as the component and that the package manager resolved compatible core and React versions.
Look for the core package used by your app and by the wrapper. If the app has several incompatible installations, align the versions before diagnosing the JSX. A team using an existing build script should also confirm it actually runs the TypeScript checker.
Hand off a React change someone can review
Give your coding agent the one-shot local feature flags guide and a short description of the observable behavior. For this shelf, the request can be as specific as the test.
The shelf controls how many public titles to display. If your actual feature unlocks paid articles, enforce access when the server serves an article. A client-rendered flag only decides what to show in that browser. Whenever a change to the display limit can wait for a deployment, the small local file keeps the decision reviewable alongside the component. When an editor needs to change it between issues without an engineering release, that's the point to consider managed rules.
Manage the shelf in GrowthBook
Start a GrowthBook workspace when your magazine team is ready to manage shelf rules between deployments.
Get Started with GrowthBookTwo customers download the same weekly report. One has agreed to preview a new CSV column. The other feeds the old two-column format into an importer. Both requests can land on the same Node.js process, and each needs the right file even if the other request arrives while the report is loading.
This tutorial builds that endpoint with one checked-in feature flag. The process loads the rules once. Each request supplies its own workspace attributes and receives its own evaluation. You can run the whole example on your machine without an account, a client key, or a flag server. The free feature flags for coding agents walkthrough introduces the local approach. Here we'll give the agent a server-specific test to pass.
Set up a small TypeScript service
Use Node.js 22 or newer for this example. In an empty directory, create an npm project that uses ES modules, install the core SDK, and add the TypeScript tools.
Create tsconfig.json at the project root. The sample runs TypeScript directly with tsx and checks types in a separate step. Type checking with tsx explains why the two commands serve different purposes.
The following files all live next to that configuration. The server imports ./flags.js even though the source file is flags.ts. That spelling follows TypeScript's Node.js module resolution for ESM and works with this runner.
Define the report contract in one flag
Create flags.ts. The public format has two columns. The sample preview workspace gets one additional column. The only targeting attribute the rule needs today is reportPreview. Carry the workspace ID too, so two people downloading a report on behalf of the same workspace can share an assignment if you introduce a percentage rollout later.
The SDK type registration update covers this rule syntax and the 2.2.0 minimum. If you misspell reportPreview in a condition or use a string where the boolean flag expects a value, TypeScript can point at the definition. The Register pattern also makes the same feature name available in other modules without threading a generic type through each handler.
Before you add the endpoint, decide what belongs to the process and what belongs to the request. The feature definitions are identical for both customers. Their identity and preview enrollment can differ. If a handler changes an attribute on a single shared user instance before awaiting a database query, another handler could replace that attribute before the first handler resumes.
Give your agent a server-side task
Use the one-shot guide to add checked-in rules. Ask your agent to keep workspace attributes local to each request and demonstrate both CSV formats.
Open the Local Flags GuideCreate a scope when the request arrives
Create server.ts. The Node.js SDK provides GrowthBookClient for the process and createScopedInstance for the current request. The two fixture paths below stand in for two authenticated workspaces. The server binds to the loopback address so you can exercise it locally.
The HTTP handler looks up a workspace, creates its scope, and holds that scope across an asynchronous operation. The short promise-based timer gives a second request time to arrive. In a real export, that's where the database or storage read would happen. Keep the stable client at module scope and the scoped instance inside the handler. If a formatter needs the decision, pass it the boolean or the scoped instance.
In production, resolve the workspace and its access rights from the authenticated session before reading the report. The two selectable paths here are fixtures for public sample data. A caller's choice of a header, query string, or workspace slug can't establish permission to read another customer's report. The endpoint also prevents shared response caching. If you cache real exports, the cache needs to distinguish the workspace and the report format, along with any other inputs that change the response.
Test two requests that overlap
In the first terminal, type-check the service and start it. A successful type check exits quietly. The next command prints the loopback address and keeps the server running.
Save the following as verify.mjs. In a second terminal, run node verify.mjs. Node's built-in fetch calls the local server. Strict assertions compare the full header and data row, including where each row ends.
You should see the single success line. Testing just the preview workspace proves that the code can add a column. Testing both responses catches the more expensive mistake of silently changing an existing customer's export. Keeping the old format assertion around is especially valuable when the downstream importer belongs to someone outside your team.
To check the compile-time boundary, temporarily change gb.isOn("includeUniqueReaders") to gb.isOn("includeUniqueReader") and rerun npx tsc --noEmit. The diagnostic should identify the misspelled key. Restore it before running the server again. A coding agent can include the before-and-after type check and the two CSV headers in its pull request.
Decide when to expand the report
When one preview customer is ready, leave everyone else on the default. If the next step is to enroll a fraction of workspaces, choose an attribute that matches the promise you're making. Hashing a workspace ID lets colleagues downloading the same report share a format. Hashing each user's ID could give two analysts in the same company different column sets. The one-shot guide shows how to express a percentage and hash attribute in a local rule.
A new rule in flags.ts reaches a process through your deployment. During a rolling deploy, the same workspace might hit old and new processes. If customers need a durable choice of export schema, keep supporting the agreed format in the API itself. When the operational requirement is to change targeting between deploys, you can keep the scoped evaluation in the handler and change how the process receives its rules.
Manage report targeting in Cloud
Create a GrowthBook workspace when the team supporting exports needs to expand the preview independently of a server release.
Get Started with GrowthBookYour conference agenda has a new “Show room” button. Reviewers should see it on the first page load. Everyone else should get the existing agenda. If a Server Component renders the old agenda and a browser hook independently decides to show the new button, the first HTML and the browser can disagree.
In the Next.js App Router, the server can make this decision once and pass a boolean to the interactive component. We'll define the flag in the repo, select the preview audience with a local test cookie, and verify the actual HTML for both visitors. Clicking the button will still work after hydration. You can follow along without a GrowthBook account or client key. If you're assigning this work to an agent, the free feature flags for coding agents walkthrough gives the background.
Keep the flag definitions on the server
Use a TypeScript App Router project, or create a small one with create-next-app. These paths assume the project has an app directory at its root. If yours uses src/app, put both app and lib under src so the relative imports still match.
Keep the starter's root layout. Create lib/agenda-flags.ts with the following code. The SDK type registration update explains how LocalFeatures checks the flag and its rule against the registered types. This setup requires version 2.2.0 or later.
The module can reuse the client and rules across requests handled by the same process. It only holds the current visitor's audience inside the function call. Two requests can therefore use the same flag file and get different results. The Node.js SDK documents the scoped client used under the App Router here.
This particular rule has no percentage and needs no visitor ID. The two audiences are sufficient. If the team later asks for a rollout to 10% of attendees, add a stable attendee or registration ID and choose which of those units should stay together. Jeremy Dorn's Register pattern article explains how a change to an attribute type reaches the call sites that construct it.
Read the cookie for this request
Create app/agenda/page.tsx. The static heading can render for everyone. The request-specific content sits behind a Suspense boundary, so the fallback can show a neutral loading message until the server has the cookie.
The App Router's cookies function reads the incoming request asynchronously. Read it inside the visitor-specific component. Keeping that read out of shared cached code lets the surrounding page reuse common content without treating one visitor's decision as another's. This placement also accommodates App Router projects using Cache Components.
Give your agent the Next.js setup
Use the local flags guide with a concrete request to evaluate one flag on the server and return the same decision to the browser.
Open the Local Flags GuideThe cookie in this demo is a convenient way to preview a public UI treatment. Anyone with that cookie can see the room label. To target paying attendees or private sessions, obtain the audience from the verified session on the server and authorize the underlying data separately.
Pass one decision to the interactive component
Create app/agenda/Agenda.tsx. It's a Client Component because a visitor can open and close the room details. Its initial branch comes directly from the boolean supplied by the page.
The client boundary takes a serializable prop. The component receives true or false. The SDK instance, targeting rules, and cookie handling stay in the server module. You don't need a React provider for this component because its only browser-side choice is whether the visitor has clicked the button.
Follow one page load through server rendering and hydration. For a preview visitor, the server can send a section with a “Show room” button. React's first client render gets the same showRoom value and starts with open set to false. Hydration attaches the click handler. Opening the room detail then updates component state and doesn't require another flag evaluation.
Verify the HTML and the click separately
Build the production app and start it on port 3100.
In a second terminal, save this as verify-agenda.mjs in the project root and run node verify-agenda.mjs. The test makes two requests to the same route and looks for a marker on the rendered section. A marker in the HTML helps catch an implementation that only adds the intended layout after JavaScript runs.
Now open http://localhost:3100/agenda in a fresh browser profile. You should see the session title without a room button. In that local page's browser console, set the demo cookie and reload.
Click Show room and look for Room 204. Click Hide room and the room should disappear. This second check proves the component became interactive. If the server response test passes but the click fails, inspect the browser console for a hydration error before changing the flag rules.
Remove the fixture and reload once more. The button should disappear and the agenda title should remain.
The reload is deliberate. Editing the cookie in an already open document doesn't rerun its Server Component. In your app, use the normal session-change flow to request a fresh server render when a visitor signs in, signs out, or leaves a preview group.
Choose where the next flag should be evaluated
For a decision needed in the initial HTML, give the agent an observable requirement. Ask it to show the two HTTP responses, then click the interactive control in the preview. The first check catches an incorrect layout. The second catches correct HTML that never becomes interactive.
If a later feature depends on an action entirely within the browser, evaluate whether its flag belongs in the client tree. The one-shot local flags guide covers both placements. This agenda only needs one server decision. Updating its checked-in rule takes a deployment. Keep that tradeoff in view if the event organizer needs to pause a preview while attendees are already arriving.
Manage the agenda rollout in Cloud
Create a GrowthBook workspace when the organizer needs to adjust a preview audience while your Next.js app is serving attendees.
Get Started with GrowthBookReady to ship faster?
No credit card required. Start with feature flags, experimentation, and product analytics—free.



