On this page
- What is agentic development?
- How agentic development differs from AI-assisted coding
- How engineering teams run AI coding agents in 2026
- The agentic workflow, step by step
- Why agentic development breaks at scale
- Workarounds that don’t hold
- An environment for every agent change
- Is agentic development worth it?
- What coding agents change for platform teams
- How to roll out coding agents across an engineering org
- Agentic development readiness checklist
Agentic development is software development in which AI coding agents take a task, plan the change, edit the code, run it, read the results and iterate until the work is ready for review. The engineer sets the goal and the constraints and decides what merges.
Most teams now run coding agents in some form. The teams that ship more because of it changed what surrounds the agent. They added clear specifications going in, a place where each change runs against the services it calls before review, and a review step sized for agent volume. The model writes the code. The system around it decides whether that code ships, and on microservices, the hardest part of that system to build is the environment each agent change runs in.
What is agentic development?
Agentic development, or agentic software development, means coding agents run the loop between writing code and checking it. An agent reads the task, decides what to change, edits files, runs commands and tests, reads the output and tries again. A person still frames the task and decides what merges, but no longer drives each step.
In Building effective agents, Anthropic draws a useful line between workflows, where models and tools follow predefined code paths, and agents, where the model directs its own process and tool use. Autocomplete and chat assistants sit on neither side. They answer one prompt and stop, and the engineer runs everything that happens next.
Agentic development is not unattended production change, and it is not a replacement for design decisions. Agents are good at well-specified work inside an existing architecture. They are weaker at deciding what the architecture should be, which tradeoffs the business accepts, or when a requirement is wrong. Teams that do well with agents keep those decisions with people and hand the agent everything after them.
Agentic coding, agentic engineering and agentic workflows
Several terms circulate for overlapping ideas. They describe different layers, and teams that mix them up end up buying a tool when they needed a process.
| Term | What it covers | What it doesn't cover |
|---|---|---|
| Coding agent | The tool: a model that can read and edit files, run commands, call services and open pull requests | Autocomplete, which suggests the next lines and runs nothing |
| Agentic coding | One engineer working through a task with an agent, in an IDE or terminal session | The team process around many such sessions |
| Agentic development | How a team builds software when agents do most of the writing: which tasks go to agents, and how their changes get verified, reviewed and merged | A product you can buy |
| Agentic engineering | The discipline of designing that system: specifications, tools and rules, verification, review policy, metrics | Prompting skill on its own |
| Agentic workflow | A fixed sequence of model and tool steps, such as ticket to draft fix to tests to pull request | An agent choosing its own steps inside that sequence |
How agentic development differs from AI-assisted coding
The difference is who runs the loop. With AI-assisted coding, the engineer asks, reads the suggestion, pastes it, runs it and judges the result. With agentic development, the agent does those steps itself, and the engineer judges the finished change.
| Mode | Who runs the loop | What it can execute | Best fit |
|---|---|---|---|
| Autocomplete | The engineer | Nothing | Typing speed on code you already understand |
| Chat assistant | The engineer | Nothing, or a snippet in an isolated runner | Explaining code, drafting a function |
| Interactive agent | The agent, watched by the engineer | Commands, tests and local services on the engineer's machine | Changes that need judgment calls mid-task |
| Background agent | The agent, unwatched | Commands inside a cloud container the vendor hosts | Well-specified tasks in parallel |
| Agent in CI | A pipeline step | What the CI runner can reach | Review comments, fixes for failing checks |
Interactive agents in the IDE or terminal
An interactive agent runs where the engineer works. Claude Code in a terminal, Cursor’s agent in its editor and GitHub Copilot in agent mode all fit here. The engineer sees each step, can stop it and can answer its questions.
This mode can run what the laptop can run: unit tests, a local build, a database in a container. On a monolith, that covers most changes. On microservices, the service the agent changed usually depends on others that don’t fit on a laptop, so the agent stubs them or stops checking.
The way past that limit is to keep only the changed service on the laptop and connect it to a shared cluster that runs everything else. Test requests for the change reach the local version, and the rest of the system stays shared, so the agent tests against the services it calls instead of stubs. Agentic local development walks through the setup.
Background agents in the cloud
A background agent takes a task and works alone, in a container or VM its vendor hosts. These are the most autonomous coding agents most teams run. Codex in the cloud, Cursor’s cloud agents and Devin work this way. The engineer gets back a branch or a pull request, often several at once from parallel tasks.
The gain is parallelism: an engineer can hand off five tasks and review the results later. The cost is reach. The container starts from a clone of the repository and whatever its setup script installs, and it has no route to services inside the company network. What the agent can verify stops at the edge of that container.
Agents in CI and code review
Agents also run as pipeline steps: review bots that comment on every pull request, and fixers that respond to a failing check. They see the diff and whatever the CI runner can reach. They add a second reader to every change, but they don’t run the change against the system it will join.
CI agents are worth having for what they catch cheaply: an unhandled error path, a missing test, a dependency bumped without its changelog read. Treat them as a filter in front of human review, not as the check that the change works. A pull request that passed an AI review and unit tests has still never met the services it calls.
Closing that gap means giving each pull request its own environment in the existing cluster, so a CI step can run the change against the services it calls before anyone reviews it. Setting that up from a pipeline is covered in pull request environments.
How engineering teams run AI coding agents in 2026
Coding agents went from early adoption to default in about a year. In the 2025 Stack Overflow Developer Survey, fielded in mid-2025, 52% of respondents either didn’t use agents or stuck to simpler AI tools, and 14.1% used agents at work daily. By May to July 2026, the JetBrains Developer Ecosystem Survey found 90% of professional developers using AI coding agents at work at least weekly, and 68% daily. The two surveys ask different questions of different samples, so read the change as a direction, not a precise growth rate.
Four patterns cover most of what teams do:
- One engineer, one agent. The engineer pairs with an interactive agent on each task. This is where most teams start.
- One engineer, several agents. The engineer runs agents on separate tasks at once, each in its own worktree or container. Running several agents in parallel on one repository needs isolation at three levels: the files, the tools and the services the tests call. The guide to running coding agents in parallel covers each level.
- A queue of agent tasks. Tickets tagged for agents go to background agents, which open pull requests for people to review.
- Agents triggered by events. A failing check, a dependency update or a new ticket starts an agent with no person asking.
Each step down that list takes a person out of the loop at one more point. Each one also raises the number of changes in flight, which is where the problems start.
How to choose coding agents for a backend team
Choose by where the agent runs and what it can verify, not by benchmark scores. Models change every few months, and most teams end up running more than one agent anyway. What lasts is how each agent fits the team’s repositories, network and review process.
Five questions separate the options for a team running services on Kubernetes:
- Where does it run? On the engineer’s machine, in a vendor’s cloud container, or in your own CI. That decides what it can reach without extra work.
- What can it execute? Shell commands, tests, local services, containers. An agent that can’t run your test suite can only guess.
- Can it call your tools? Support for MCP servers and command-line tools decides whether it can create a test environment, read CI results or query a service on its own.
- What does it hand back? A diff, a branch, or a pull request with the commands it ran and their output. Evidence shortens review more than a cleaner diff does.
- What does it need access to? Repository scope, secrets and network access. A background agent with broad credentials is a security review waiting to happen.
Most backend teams settle on two modes: an interactive agent for changes that need judgment, and a background agent for well-specified tasks in parallel. The deciding question for both is the same: can the agent test its change against the services it calls before it opens a pull request?
The agentic workflow, step by step
An agentic workflow wraps an agent in fixed steps that people own at both ends. The agent decides how to do the work in the middle. The team decides what counts as done and what merges.
- Specify. A person writes the task as behavior: what should change, what must not, how to tell. Acceptance scenarios belong outside the code, where the agent can’t rewrite them to pass. Keeping a specification beside the code with a tool such as OpenSpec, and running integration tests against it inside the loop, is the pattern in OpenSpec with integration tests inside the agent loop.
- Plan. The agent reads the code and proposes an approach. For larger changes, a person approves the plan before any edits.
- Implement and verify. The agent edits, runs and checks in a loop until the specification’s checks pass.
- Open the pull request. The pull request carries the evidence: which tests ran, against what, with what result.
- Review and merge. A person reads the change for intent, design and risk, then merges.
Step 3 decides most of what happens after it. An agent that can only run unit tests stops when the unit tests pass, and every integration fault reaches the reviewer or the next shared environment. Why loops close too late, and what that costs in iterations and tokens, is the subject of the feedback problem in agent loops.
Why agentic development breaks at scale
Agentic development breaks where generation outruns verification. Agents raise the number of changes a team produces. The capacity to prove those changes work stays where it was, so work piles up at the first step that still runs at human speed.
That step is usually one of three places:
- The review queue. Reviewers face more and larger diffs, written by an author that can’t explain its reasoning in a hallway conversation. Review slows, or it turns into a skim. The gap between code written and code anyone has proven works has a name: verification debt.
- The shared environment. Changes that pass on the laptop or in the cloud container still need to meet the real services somewhere. If that somewhere is one shared staging environment, every agent change joins one queue, and one bad deploy blocks all of them. The staging trap for coding agents in enterprise Kubernetes walks through how that queue forms.
- The agent’s own tests. When an agent can’t reach a dependency, it often writes a mock of it. The mock agrees with the agent’s assumptions, the test passes, and the integration is still broken.
All three have one mechanism in common. The agent’s feedback comes from something that isn’t the system the change will run in, so passing checks stop predicting a working deploy. The fix has to bring the real system closer to the agent, not add more checks in the places that already pass.
Workarounds that don’t hold
Teams under that pressure reach for fixes that help for a few weeks. Each one stops working as agent volume grows.
- More reviewers, or an AI reviewer on every pull request. Review reads the diff. It can’t see a timeout set shorter than a downstream retry, or a field the consumer still expects. A second reader finds style and logic slips, not behavior across services.
- More unit tests and mocks. Agents write tests quickly, and they write the mocks too. A suite that grows faster than the real integration surface gives a green build more often and means less each time.
- Small changes only. Capping agents at trivial tasks keeps the risk down by keeping the gain down. It also leaves the team unready when the cap lifts.
- A bigger shared staging environment. More capacity in one environment still means one queue and one set of shared state. Agent volume fills it again.
Each of these moves the queue rather than removing it. None of them changes where the agent’s feedback comes from.
An environment for every agent change
The fix that holds moves verification into the agent’s loop. Every agent change gets its own production-like environment, and the agent runs its checks there before a person sees the pull request. The agent tests against the services it calls instead of its own mocks, no change waits for a shared stage, and the reviewer gets a change that has already run.
That last point is the one that scales review. The argument for a machine verifier in front of the human one is made in async coding agents need a verifier that isn’t a person.
Ephemeral environments give each change that place to run, and they come in two shapes. One is a full copy of the stack per change, such as a namespace or a cluster per pull request. The other is a lightweight ephemeral environment that runs only the services the change modified and shares one set of stable services for everything else.
A full copy has no shared state to reason about and suits a small stack. Its start time and cost grow with the stack, though, and agents multiply both: thirty parallel agents need thirty copies of every service, database and queue. A lightweight environment starts as fast as the changed services deploy and costs about what they cost, so one per agent task stays affordable. Both shapes, with their costs at volume, are set side by side in ephemeral environments on Kubernetes.
The tradeoff of the lightweight shape is shared state. By default, every environment reads and writes the same databases and queues, which is fine when tests partition their data and clean up after themselves. A change that can’t share safely, such as a schema migration or a destructive test, needs its own copy of that dependency for as long as the environment lives.
For agents, the lightweight shape has one more advantage: it runs inside the Kubernetes cluster the team already has, so an agent can create an environment, check its change there and delete it within a single task. How lightweight ephemeral environments work covers the model in more depth. Claude Code verifying a microservices change in a closed loop shows an agent running that loop from edit to passing end-to-end test.
Is agentic development worth it?
Yes, for teams that build the verification around the agent before they scale the agent. Teams that hand out licenses and wait for productivity get more code, more review load and a mixed result.
The evidence points both ways, which is why the setup matters. In a controlled trial, METR found experienced open-source developers took 19% longer on tasks in their own repositories when they used early-2025 AI tools. METR calls it a snapshot of tools that have since changed. It still shows that access to an agent doesn’t produce speed on its own.
The 2025 DORA report describes AI as an amplifier that magnifies an organization’s existing strengths and weaknesses. For coding agents, the strength that gets amplified or not is the check: a team where every change can be tested against the real system gets faster, and a team without one gets more code waiting in the same queues.
It isn’t worth it yet for every codebase. A service with no tests, no way to run it outside production and no one who understands it gives an agent nothing to check against, and its changes land on reviewers as unverified guesses. Fix the test path for that service first, then hand it to agents.
Take a position on where the return comes from. It doesn’t come from picking the best model, which changes every quarter. It comes from how quickly and how faithfully each agent change can be checked against the real system. That decides how much work the agent finishes and how much it hands back to a person.
What coding agents change for platform teams
Agents change who the platform serves. Until now, developer environments were requested by people, a few at a time, through a ticket, a script or a portal. In agentic development the main user is software: agents request environments in the middle of a task, many at once, often from machines with no network path to the cluster.
That mechanism is specific to agents. A person who needs a test environment waits, asks a colleague, or tests later. An agent in its loop either gets an environment in seconds through a call it can make, or it falls back to whatever it can run alone, which on microservices means mocks.
Background agents can’t reach your services
Cloud agents start in a container outside your network. Codex’s cloud environment settings let you choose how much public internet access each environment gets, but services inside a private cluster aren’t on the public internet. Handing the agent a kubeconfig or a VPN profile gives an unwatched process broad access to shared infrastructure, which most platform teams won’t approve.
The pattern that works gives the agent a scoped way in. The container connects out to a control plane with a scoped key, and the control plane relays test traffic between the cluster and the changed service running in the container. The agent never holds cluster credentials, and the rest of the system stays shared.
The coding agent tutorials set this up for background agents such as Codex and Devin.
Environments become a call inside the agent’s loop
When agents are the users, an environment has to be something an agent can create, use and delete through an API, a CLI or an MCP server, in seconds and without a ticket. The agent’s change has to run against the real services it calls, at a cost low enough to create one per task. What that check has to prove for an AI-written change is laid out in verifying AI-generated code on Kubernetes before merge.
Agents also make some of the platform team’s work lighter. They follow the documented path every time, read error output in full and retry without complaint. A platform that exposes environments as a clean, scoped API often finds agents use it more consistently than the humans did. How far an agent’s own run reaches into the system, from the edited file to the whole call graph, is the subject of what runtime verification by coding agents reaches.
In practice that is an MCP server for environments, or a CLI where the agent has no MCP client. The platform team sets up the cluster once, and agents create and delete their own environments from there.
How to roll out coding agents across an engineering org
Roll out the verification path before the volume. A team that adds agents to 300 engineers on top of one staging environment gets more pull requests waiting in the same queue. A team that first gives each change a place to run can add agents without adding instability.
- Pick the task types. Start where a wrong change is cheap to catch: dependency updates, test coverage, internal tools, well-specified bug fixes. Leave schema migrations and authentication for later.
- Write the rules down. Repository instructions, coding standards and the commands an agent should run go in files the agent reads at the start of every session.
- Give agents a way to run changes against real services. Every agent change needs its own production-like environment before the pull request opens, created by the agent itself through a CLI or MCP server.
- Set the review rule. Decide which changes need a full read and which need a check of the evidence. Make the pull request carry that evidence.
- Measure from day one. Track change failure rate and review time before the rollout, so you can tell whether agents help or only add volume.
Step 3 is a one-time install in the cluster you already run plus a connection in each agent’s setup. The coding agent integration docs cover that connection for the common agents.
The infrastructure side of a rollout, from cluster capacity to environment cost, is laid out in why your infrastructure isn’t ready for agentic development at scale.
Measuring whether coding agents help
Measure delivery, not output. Lines of code and pull requests opened rise with any agent rollout, whether or not anything ships faster.
Four numbers tell you whether agentic development is working:
- Change failure rate. If it rises as agent share rises, verification is lagging generation.
- Lead time from task to production. Agents should shorten it. If it stays flat while pull requests multiply, the queue moved downstream.
- Review time per pull request. Rising review time means reviewers are doing the verification the pipeline skipped.
- Agent pull requests merged without rework. The share an engineer accepts as written, tracked by task type, shows which work to hand off next.
Track them by task type and by agent mode, interactive and background, because a background agent with a poor verification path drags the average down for everyone. For an organization running agents as a full pipeline from ticket to production, the complete guide to software factories covers how much autonomy that pipeline can safely run and how to measure it.
Agentic development readiness checklist
Answer each one yes or no for the services agents touch most:
- Do agents get each task as a written specification with acceptance checks?
- Are acceptance scenarios stored where the agent can’t edit them to pass?
- Does every repository carry instructions the agent reads at session start?
- Can an agent run its change against the real services it calls before opening a pull request?
- Can several agents test changes to the same service at once without colliding?
- Can a background agent reach a test environment without cluster credentials?
- Are agent-written mocks reviewed with the same suspicion as agent-written code?
- Does each agent pull request carry evidence of what ran and what passed?
- Is there a written rule for which agent changes need a full review?
- Do you track change failure rate and review time separately for agent changes?
- Is there a list of task types agents may not take on yet?
- Does the cost of a test environment stay low enough to create one per agent task?
Related reading
- Running Coding Agents in Parallel: Worktrees, Containers and One Shared Cluster
- Coding Agents Run Their Own Code Now. How Much of the System Does That Reach?
- Watch Claude Code Validate a Microservices Change in a Closed Loop
- OpenSpec: Integration Tests Inside the Agent Loop
- The Staging Trap: How to Unblock AI Coding Agents in Enterprise Kubernetes
- Async Coding Agents Need a Verifier That Isn't a Person
- Your infrastructure isn’t ready for agentic development at scale
- Ephemeral Environments for Coding Agents
Frequently asked questions
What is agentic development?
Agentic development is a way of building software where AI coding agents take whole tasks: they plan the change, edit files, run commands and tests, read the results and iterate until the work is ready for review. Engineers set the goal, write or approve the specification, and decide what merges. The difference from AI-assisted coding is who runs the loop between writing code and checking it.
What is the difference between agentic coding and agentic engineering?
Agentic coding is one engineer working through a task with an agent, usually in an IDE or terminal session. Agentic engineering is the discipline of designing the system around many such sessions: the specifications agents work from, the tools and rules they get, how their changes are verified, who reviews what, and which metrics show it works. A team can do the first well and still fail at the second.
What is an agentic workflow?
An agentic workflow is a sequence of model calls and tool steps that a team defines in advance, such as triage a ticket, draft a fix, run the tests and open a pull request. Anthropic separates workflows, which follow predefined code paths, from agents, which choose their own steps. Most engineering teams use both: a fixed workflow around the change, with an agent deciding the steps inside it.
What are AI coding agents?
AI coding agents are tools that pair a language model with the ability to act: read and edit files, run shell commands, call APIs and MCP servers, and open pull requests. Claude Code, Codex, Cursor's agent, GitHub Copilot's coding agent and Devin are common examples. Some run interactively beside the engineer, others run in the background in a cloud container and report back with a finished branch.
Do you need a separate environment for every coding agent?
You need a separate place for each agent change to run, or parallel agents overwrite each other's work and test results. That doesn't have to mean a full copy of the stack per agent. For agentic development on microservices, a lightweight ephemeral environment that runs only the changed services and shares the stable ones gives each agent its own space at a fraction of the cost.
Do coding agents replace code review?
No. Review still decides what merges, but its job changes. When AI coding agents write most of the diffs, reviewers can't read every line with the care they gave human changes. The answer is to verify behavior before the pull request opens, so reviewers spend their time on design, intent and risk rather than on finding out whether the code runs.
How do you roll out coding agents to a large engineering team?
Start with task types where a wrong change is cheap to catch, then build the verification path before adding volume. Give agents specifications and repository rules, a way to run each change against the services it calls, and a review rule sized for their output. Measure change failure rate and review time from the start, so a coding agent rollout that adds instability shows up early.
Can background coding agents test against internal services?
Not by default. Background agents such as Codex in the cloud or Devin run in a container the vendor hosts, which has no network path to services inside your cluster. To test a change end to end, the agent needs a way in that doesn't hand it cluster credentials, such as a connection relayed through a control plane with a scoped API key.
How do you measure agentic development?
Measure delivery, not output. Lines of code and pull requests opened go up with any agent. The useful numbers are change failure rate, lead time from task to production, review time per pull request, and the share of agent pull requests merged without rework. If agentic development is working, throughput rises while change failure rate holds or falls.