80% of organizations adopted AI coding tools faster than they built the policies to govern them, and 92% now report governance challenges with AI-generated code. That is not a guess. It is the headline finding of GitLab's 2026 AI Accountability Report, a Harris Poll survey of 1,528 developers and technology buyers across six countries.
The part of that report that should worry a VP of Engineering more than any other: 85% of respondents agree the bottleneck has shifted from writing code to reviewing and validating it, and among organizations that already suffered a production incident, 34% could not determine whether AI-generated code had contributed to it, despite 87% saying they were confident they could.
Coding agents writing, testing and reviewing code are the easy part now. The real question behind AI agents for software development is what watches the agents themselves: who approves the merge, who sees the failing pipeline before it blocks the whole team, who catches a poisoned issue title before it turns into a supply chain incident. That last one is not hypothetical. It already happened.
In a hurry? Put one of Rerun's coworkers on your engineering workflows instead of reading the whole thing.
What "AI agents for software development" actually means
Three things get lumped together under this phrase, and they are not the same tool.
A coding assistant (Copilot, Cursor's autocomplete) suggests code inline. It reacts to what you type, right where you type it, and a human accepts or rejects each suggestion on the spot.
A CI/CD script runs a fixed path every time. Lint, test, build, deploy. It is reliable precisely because it never improvises, and it breaks the moment reality falls outside the path someone wrote months ago.
An AI agent plans, takes action across several systems (the repo, the CI pipeline, the ticket tracker, the monitoring dashboard), and adapts its next step based on what it finds. It can open a PR, read a stack trace, triage a security alert, or page someone on call, without a human writing the exact sequence of steps in advance.
| Reacts or plans | Acts across systems | Needs a human per step | |
|---|---|---|---|
| Coding assistant | Reacts | No, stays in the editor | Yes, every suggestion |
| CI/CD script | Follows a fixed path | Yes, but only the path written | No, until it breaks |
| AI agent | Plans and adapts | Yes, across tools | Only at the gates you set |
If you want the mechanics of how that planning loop actually works (plan, act, verify, repeat), our deep dive on agentic coding covers it in detail. This article stays one level up: not how an agent reasons, but what it means to run a fleet of them safely inside a real engineering org.
The three levels of autonomy, applied to engineering actions
Not every agent in your SDLC needs, or should have, the same leash. Three tiers, in increasing order of risk:
Advisory. The agent suggests a fix, a test, or a root cause. A human writes the actual change. Risk is close to zero: the worst case is a bad suggestion nobody acts on.
Supervised. The agent opens the PR, files the ticket, or drafts the changelog entry. A human approves before anything ships, merges, or gets sent externally. This is where most of the real leverage lives, and where most mature teams should be operating today.
Autonomous. The agent merges, deploys, or pages someone without a human in the loop at all. Appropriate for a narrow set of low-blast-radius actions (auto-merging a dependency bump that passes every check, for instance) and rarely appropriate for anything that touches production, customer data, or an external communication.
Confusing these tiers is where things go wrong. An agent operating at "advisory" trust that was quietly granted "supervised" permissions, through a scoped-too-broadly CI token or an --allowedTools flag nobody revisited, is exactly the setup that produced the incident in the next section.
What AI agents can actually do in software development today
Code review and PR triage
An agent can read a diff, summarize the intent, flag the riskiest files (auth, payments, anything touching a migration), and decide which of the 30 open PRs actually need a human's attention this morning. It does not replace a reviewer's judgment on a complex change. It stops reviewers from spending their first hour just figuring out where to look.
Test generation and flaky test triage
Writing a test for a function is a well-bounded task an agent handles reasonably well. More valuable, and less talked about: an agent that notices a test has failed intermittently across the last 20 runs, correlates it with a recent dependency bump, and opens a ticket with the pattern already documented, instead of a human discovering it three sprints later when it finally blocks a release.
CI/CD pipeline monitoring and build-failure triage
This is the use case that compounds fastest, because CI failures are frequent, structured, and expensive in attention even when they are cheap in actual fix time. An agent that watches the pipeline, classifies a failure (flaky test, real regression, infra blip, dependency conflict), and routes it to the right owner with context attached saves the 20 minutes every engineer currently spends just figuring out what broke.

DevOps Engineer
Automate Deployments and Releases
Fifteen minutes of setup, and every build failure arrives already triaged instead of as a bare red X in Slack.
Documentation and changelog generation
Drafting a changelog from a batch of merged PRs, or keeping a README's setup instructions in sync with what the code actually requires, is exactly the kind of low-stakes, high-frequency writing task that an agent can draft and a human can approve in seconds.
Security and dependency alert triage
Dependabot and your SAST scanner generate more alerts than any team reads in full. An agent that reads each one, checks whether the vulnerable path is actually reachable in your code, and routes the real findings to the owning team is the difference between a security backlog nobody opens and one that actually gets worked.
Incident triage and on-call support
When something breaks at 2am, an agent that correlates the alert with recent deploys, pulls the relevant logs, and proposes a likely cause gives the on-call engineer a running start. It should propose and page, not auto-remediate. Rolling back a deploy or restarting a production service is exactly the kind of autonomous action that belongs behind a human approval, every time.

Incident Manager
Manage Incidents and Write Postmortems
The agent does the correlation work before anyone is fully awake. The human still decides what happens to production.
Where AI agents break: the risks engineering can't ignore
The risks here are not generic "AI might be wrong" caveats. They are specific to what happens when an agent has real tool access inside your SDLC.
Confident wrong fixes. An agent that misdiagnoses a root cause doesn't say "I'm not sure." It proposes a fix with the same tone of confidence as a correct one. A reviewer who has learned to trust the agent's suggestions stops checking as carefully, which is its own risk, sometimes called human-agent trust exploitation.
Over-permissioned tokens. The OWASP Top 10 for Agentic Applications calls this Identity and Privilege Abuse, and names "least agency" as the core defense: an agent should hold only the permissions its declared task actually needs, nothing bundled in for convenience. A CI bot with a repo-wide personal access token is the software engineering equivalent of giving every intern the master key.
Prompt injection through untrusted input. This is the one most teams haven't internalized yet: an issue title, a PR description, a README, anything an agent reads as part of its normal job, can carry instructions an attacker wrote, not the project maintainer. The agent has no reliable way to tell the difference between "the task" and "a line someone else slipped into the task's context."
Supply chain compromise through the agent's own pipeline. In February 2026, exactly this chain played out against Cline, an AI coding tool with more than 5 million users. An attacker planted a prompt injection inside a GitHub issue title. The project's own AI triage bot, running with broad Bash/Write/Edit permissions and no restriction on who could trigger it, executed the attacker's payload. From there the attacker pivoted through GitHub Actions cache poisoning into the nightly release pipeline, and eight days later published an unauthorized package version to every developer with auto-updates on.
How “Clinejection” Turned an AI Bot into a Supply Chain Attack | Snyk A prompt injection in a GitHub issue title gave attackers code execution inside Cline's CI/CD pipeline, leading to cache poisoning, stolen npm credentials, and an unauthorized package publish affecting the popular AI coding tool's 5 million users. Here's the full technical breakdown and what developers should do now."If the attacker can remotely prompt it, that's not just malware, it's the next evolution of C2. No custom implant needed. The agent is the implant, and plain text is the protocol."
That line, from security researcher Yuval Zacharia on the Cline incident, is the single clearest way to say why this risk category is different from every CI/CD attack that came before it. The entry point wasn't a code vulnerability. It was a sentence.
No audit trail. When an agent proposes a fix, touches a file, or triages an alert, can anyone answer "what exactly did it do, and who approved it" six weeks later? For most teams running agents today, the honest answer is no.
Cascading failures. When one agent's output becomes another agent's input with no independent check in between, a single bad call at the top of the chain propagates without anyone catching it until the damage has already spread.
How to deploy AI agents in software development safely
A short, concrete checklist, not a philosophy:
This is where Rerun's own position needs to be stated plainly, because it would be easy to read this article as a pitch for a coding tool, and it isn't one. Rerun does not write code, review a diff, or act as a coding agent. Coding agents like Copilot, Cursor, Claude Code, or Codex do that job, inside the repo, and this article has no opinion on which one you should pick (our coding agent comparison does, if that's what you're after).
What Rerun is: the human-in-the-loop layer that runs around those agents and the rest of your SDLC. A coworker watches CI for a failing build and opens a ticket instead of silently retrying. A coworker triages the Dependabot queue and routes the real findings to the right engineer. A coworker drafts the changelog from merged PRs and waits for a thumbs-up before it posts. A coworker correlates an incident's signals and pages the right human, with the full reasoning logged, before anything touches production.
The concession that matters here: Rerun does not decide what good code looks like, and it will not replace a senior engineer's judgment on a risky change. It is the layer that makes sure every agent action, including the coding agent's, has an owner, a log, and a gate before it matters.
Why not just use a CI script, or the coding agent's own automation?
| CI/CD script | Coding agent alone | Governed agent layer | |
|---|---|---|---|
| Handles the unexpected | Breaks on anything outside the written path | Acts on code, but has no view outside the repo | Watches across repo, CI, tickets, and alerts |
| Visible to non-engineers (security, EM, product) | Lives in a YAML file nobody outside the team reads | Lives in the IDE or the PR | A dashboard anyone on the team can read |
| Approval gate before a real action | None, it just runs | Depends entirely on how it's wired | Built in, by design |
| Audit trail of what happened and why | A scrolling log, if that | Usually just the diff | Every action, logged and replayable |
A flowchart automation tool like Zapier, Make, or n8n solves a different problem than any row in that table: wiring two SaaS apps together on a trigger. That's fine for "when a PR merges, post to Slack." It is the wrong shape entirely for "watch 40 repos, correlate failures across them, and decide who should look at what first," because a flowchart has no judgment, only branches someone wired in advance. A chatbot is a different wrong shape again: it waits for you to ask, instead of noticing the build broke at 2am and doing something about it before you're even awake.
A 30-day rollout you can actually run
Week 1. Pick one low-risk, high-frequency workflow. CI-failure triage or changelog drafting are good first picks: frequent enough to matter, low-stakes enough that a mistake costs minutes, not an incident.
Week 2. Run it supervised. Every proposal gets a human approval. Log the agent's accuracy: how often was the triage right, how often did the draft need real edits.
Week 3. Tune scope based on what week 2 showed. Tighten permissions anywhere the agent reached further than it needed to. Widen the task slightly if accuracy was consistently high.
Week 4. Measure the actual time saved against the actual review burden it added, and decide honestly whether to extend it to a second workflow or hold where you are. That is the whole point of rolling out AI agents for software development gradually: the governance habits you build in week 1 are what let week 20 scale without a Clinejection-style surprise.
{
"goal": "Triage failing CI builds across the repo and route them to the right owner",
"watch": ["pull_request CI status", "main branch CI status"],
"on_failure": [
"read the failing job's logs",
"classify as flaky_test, real_regression, infra_issue, or dependency_conflict",
"if flaky_test: check last 20 runs for the same test, attach pattern if found",
"identify the owning team from CODEOWNERS",
"draft a ticket with classification, logs excerpt, and likely owner"
],
"approval_required": ["opening the ticket", "tagging a specific engineer"],
"never": ["re-running the pipeline automatically", "merging any change", "closing the PR"]
}That is the shape of a supervised-tier brief: narrow watch list, a clear classification step, an explicit approval gate, and an explicit "never" list. Most of the safety in week 1 comes from how specific that brief is, not from the model behind it.
Engineering coworkers you can run today
Frequently asked questions
What are AI agents for software development?
They are systems that plan and take action across the tools an engineering team already uses (the repo, CI/CD, the ticket tracker, monitoring), rather than just suggesting code inline. Typical uses include PR triage, test and build failure triage, documentation drafting, security alert routing, and incident correlation.
How is an AI agent different from a coding assistant like Copilot?
A coding assistant reacts to what you're typing, right in the editor, and a human accepts or rejects each suggestion immediately. An agent plans ahead, acts across several systems on its own, and only needs a human at the approval gates you set, not at every single step.
Can AI agents replace code review?
No. They can triage which PRs need attention first, summarize a diff's intent, and flag risky files, which cuts the time a reviewer spends just finding where to look. The judgment call on a genuinely risky change still belongs to a human reviewer.
What's the biggest security risk of AI agents in the SDLC?
Prompt injection through untrusted input (an issue title, a PR description, a comment) combined with an agent that has broad tool access. The Clinejection incident against Cline in February 2026 showed exactly this chain, from a single GitHub issue to a compromised npm release, in eight days.
Should an AI agent be allowed to merge or deploy on its own?
Rarely, and only for narrow, low-blast-radius cases, like auto-merging a dependency bump that passes every check. Anything that touches production, customer data, or an external communication should sit behind a human approval gate, every time.
How do you keep AI agents from having too much access to your repo and CI?
Give each agent its own scoped, short-lived credential instead of a shared, repo-wide token. Apply OWASP's least agency principle: grant only the permissions the declared task needs, and isolate nightly release credentials from production publishing credentials so one compromise can't reach the other.
What's the difference between an AI agent and a CI/CD automation script?
A script follows a fixed path every time and breaks the moment something falls outside it. An agent plans its next step based on what it actually finds, which makes it more useful for triage and correlation, and is exactly why it needs an approval gate a script never did.
How do you deploy AI agents in your engineering org safely?
Start with one low-risk, high-frequency workflow running supervised, with every action logged and approved by a human. Scope credentials tightly, map your controls to the OWASP Top 10 for Agentic Applications, and only widen scope once a few weeks of supervised accuracy data back the decision.





















