See what happens after a coding agent opens a pull request: pipeline checks, risk-ranked review, safe deployment, and where humans approve the risky steps.

Short answer: An autonomous SDLC is a delivery process in which AI agents write, test, secure, review and ship changes, while policy gates enforce your rules and humans approve the risky steps. The agent opening a pull request is only the midpoint. What happens next, from pipeline to review to production, decides whether AI-written code ships safely or becomes an incident.
What is an autonomous SDLC?
In a traditional SDLC, people move each change from stage to stage. Someone reviews it, someone starts the build, someone approves the deployment. In an autonomous SDLC, agents do that work and policy connects the stages in place of tickets and queues. Coding agents write the change. Delivery agents build, test, secure, review, deploy and verify it. People decide how much autonomy each kind of change gets, and they sign off on anything risky.
"Autonomous" does not mean "unsupervised." The practical model is risk-based autonomy, where you choose the level per task, per environment and per team:
- Autonomous for low-risk changes, such as dependency bumps and dev-environment work.
- Human in the loop for standard production changes, new services and security fixes. Agents prepare the change and a person approves it.
- Deterministic for the highest-risk paths, such as payments, regulated data and destructive schema operations. These follow fixed steps and gates, exactly as they do today.
Identity, policy, enforcement and evidence stay the same across all three tiers. That is the idea behind Harness's Software Delivery Agent, which takes code, infrastructure and database changes through production under the policies you define. It also reflects a broader argument in which AI writes the code. Who delivers it safely?: the system around the model decides what an agent can see, what it can do, and what happens when it is wrong.
Here is how the stages fit together:
If your team is also shipping AI agents themselves, rather than just agent-written code, the lifecycle has extra stages. Harness Agent DLC covers testing, deploying and governing the agents.
What happens after a coding agent opens a pull request?
In a well-governed pipeline, the pull request moves through the sequence below. Steps 1 to 5 can overlap, so the human reviewer opens a pull request that has already been built, scanned, triaged and ranked.
- The pipeline runs. The pull request triggers a build and the test suite automatically, because agent output varies too much to rely on someone remembering to start the checks. Harness Builds uses Test Intelligence to run only the tests a change affects, which keeps feedback fast as volume climbs.
- Security scans run. Static analysis, dependency analysis and secrets detection run as pipeline stages against the diff and its dependencies. They catch what the agent's own tests won't, such as a library version with a known vulnerability that the model learned from older data.
- Findings are triaged and deduplicated. Several scanners often flag the same issue, and most findings are not exploitable. Harness's Triage Agent prioritizes CVSS, EPSS and reachability analysis, so people see the findings that represent real risk.
- A policy check decides whether the change can proceed. Policy as code, using Open Policy Agent, confirms that required checks passed, approvals exist and no check was weakened. Because the gate lives in the pipeline, the agent cannot route around it.
- Review happens, with the risky part first. AI Code Review groups the diff logically, ranks it by risk, runs the custom checks your team defined, and grounds its feedback in your SDLC Knowledge Graph, including past incidents. Required checks that fail block the merge, and a person reads the part that needs judgment.
- The change unfolds gradually. Approved changes roll out using canary, blue/green or rolling strategies. Autonomy follows risk: low-risk changes can go out hands-free, while tier-1 production paths follow a fixed route with an explicit approval.
- The release is verified. AI Verification compares live metrics and logs with the previous version and triggers a rollback or an alert if the new release performs worse. The pipeline also records what ran and which policies applied, so "prove what happened" has an answer.
How do teams review hundreds of agent pull requests?
They stop giving every pull request the same attention. GitHub's guidance on reviewing agent pull requests describes the squeeze: one developer can launch many agent sessions in a morning, while the number of reviewers stays the same. It also cites research finding that agent-written changes tend to add more redundancy and technical debt, even when the code looks clean. Automated review has to read everything first, and humans need a short list of what to look for.
A red-flag checklist for agent pull requests
- Weakened tests. Look for deleted or skipped tests, assertions that got looser, lowered coverage thresholds, and mocks that replace the very thing a test was meant to exercise. An agent that is trying to turn CI green can get there by weakening CI, so any change that does is a blocker until someone justifies it.
- Edited workflow files. CI/CD configuration, build scripts, Dockerfiles, install hooks and agent instruction files all run with elevated trust. Changes to them deserve a named reviewer, even when the pull request description says they are routine.
- Duplicated utilities. Agents see only part of your codebase, so they often write a new helper that does what an existing one already does. Search before approving, and require consolidation instead of leaving a comment.
- New dependencies. Confirm that every added package exists, has a real history and maintainer, and has no known vulnerabilities. Models sometimes suggest packages that don't exist, and attackers register those names.
- Secrets. Check for credentials in code, logs and config, and for workflows that hand tokens to an agent step with more permission than it needs.
A rule for what must reach a human. If a change weakens a check, alters how code is built or deployed, or adds something new to trust (a dependency, a permission, a workflow), a person approves it. Anything touching production paths, authentication, payments or regulated data goes to a person as well, however clean it looks. Everything else is decided by risk tier, which lets low-risk work such as routine dependency updates pass under policy. OWASP's guidance on secure coding with AI adds the accountability piece: every AI-generated change needs a human owner who approved it, and an AI reviewer does not replace that person.
Can AI agents fix security vulnerabilities safely?
Yes, under three conditions.
- Scoped changes. Each fix should address one finding, touch as few files as possible, and arrive as a pull request. A narrow change is easy to review and easy to revert.
- Tests as the gate. A fix is only as trustworthy as the test that proves it. OWASP warns against letting the same agent write security-critical code and the tests that vouch for it, so keep at least some tests independent.
- Sign-off by severity. Match the approver to the risk. A low-severity patch in a well-tested service can follow a light review, while high-severity fixes need a named approver, and changes to authentication, cryptography or authorization always get a person.
Generated fixes can be wrong. They may not close the vulnerability, or they may introduce a new problem, which is why the pull request and the tests matter. In Harness, the Triage Agent and Remediation Agent work this way. The Triage Agent ranks findings by exploitability. Harness AI then drafts the fix: the Remediation Agent writes it, validates it in the pipeline so it doesn't break the build, and opens a pull request for developer review, and developers keep merge authority. The agents run in the pipeline under its policy gates and approvals, and each action is recorded in the audit trail. For the wider governance model for agents that run as pipeline steps, see Autonomous Worker Agents.
If your security team maps to NIST, the Secure Software Development Framework is the usual baseline, and its generative AI profile extends it to AI model development. Neither is a checklist for reviewing agent pull requests, so pair them with day-to-day guidance like OWASP's.
Can AI-generated code be deployed to production safely?
Yes, if the pipeline protects production instead of relying on confidence in the author. Four controls do most of the work:
- Progressive delivery. Release to a small share of traffic first with canary, blue/green or rolling strategies, then widen the rollout as health holds.
- Feature flags. Separate deployment from exposure, so a change can reach production switched off and be turned on gradually, or off again without a redeploy.
- Automated rollback. AI Verification watches live metrics and logs, and reverts a release that performs worse than its predecessor, without waiting for someone to notice, diagnose and back it out by hand.
- Policy as code. Required checks, approvals and freeze windows are enforced in the pipeline, so a change that skipped them cannot ship, whether a person or an agent wrote it.
Speed is also a damage multiplier when it comes to AI coding. An agent with weak context can open ten broken pull requests in ten minutes, and a delivery process without verification can ship a lot of them before anyone looks. When a release spans several services, Release Orchestration sequences the dependent pieces as one coordinated, auditable release. And it helps to remember that the tiers still apply: let low-risk changes move on their own, and keep tier-1 production on a deterministic path until you trust the evidence.



.webp)