What is agentic dev, and when is it worth doing?

The short version

• Agentic development means an AI agent plans and carries out multi-step software work, and a person reviews the result.
• The difference between an agent and autocomplete is the loop: an agent acts, checks the outcome and chooses its next step without a new prompt.
• The term 'agentic development' has two meanings: using agents to build software, and building agents into products.
• The seat price of a coding agent is usually the small cost, and staff time for specifying and reviewing the work is the large one.
• No speed-up figure for agentic dev is settled, and METR calls its own recent result an unreliable signal.

What does agentic dev mean?

Agentic dev means giving an AI agent a goal and letting it work through the steps itself. The agent reads the relevant code, makes a plan, edits files and runs commands and tests. It then reads the output and tries again if something failed. A person sets the goal and the limits, and reviews what comes back.

The defining feature is the loop. Autocomplete suggests the next line and stops. A chat assistant answers one question and waits. An agent takes an action, looks at what happened and chooses its next action. It keeps going until the work is finished, it gets stuck or it hits a limit somebody set.

That loop also changes the risk. A bad suggestion costs nothing until a developer accepts it. A bad action from an agent may already have happened by the time anyone looks, so the limits have to be set before the run, not after it.

Does agentic development mean using agents or building them?

Agentic development means both, so check which one somebody means. The first sense is using agents to write and change software, often called 'agentic coding'. The second is building agents into a product or business process, such as an agent that handles support requests or moves documents through a workflow.

The mechanics are shared: a model, a set of tools, a loop, a stop condition and permissions. The exposure is not. In agentic coding, the agent's work can wait in a branch until a person has read it. In a product, the agent acts at run time, often in front of a customer or on live data, and nobody reads each step before it lands.

So the two senses need different safeguards. Agentic coding leans on tests and code review. A production agent needs evaluation before release, monitoring afterwards and a way to hand a case to a person. This guide is mainly about the first sense.

How is agentic dev different from autocomplete and vibe coding?

The difference is who decides the next step and who checks the work. With autocomplete, the developer does both. In agentic dev, the agent decides the next step inside a scope a person set, and a person still checks the result. In vibe coding, as the term is usually used, the checking is often skipped.

What are the steps in an agentic development workflow?

An agentic development workflow has six steps: write a checkable task, limit the agent's access, let it run, check the result independently, review the diff, and feed mistakes back into the instructions. Most of the human effort sits at the start and the end, not in the middle.

1. Write the task so the result can be checked. Name the change, the files in scope and what 'done' looks like.
2. Limit what the agent can touch. Give it a branch or a sandbox, and no production credentials.
3. Let it work. It reads code, edits files and runs tests in a loop until it stops or hits a limit.
4. Check the result with something the agent did not write. If it wrote both the code and the tests, passing proves little.
5. Read the diff as you would a colleague's, then merge it or reject it.
6. Fix the instructions as well as the output. When the agent repeats a mistake, add a test or a project rule so it stops.

How widely is agentic development used at work?

Agentic AI is in use at work, but cautiously. Stack Overflow's pulse survey of 1,100 developers and working professionals, from late April 2026, describes it as remaining mostly single-agent and monitored at work. The respondents are technical people, so the survey does not describe small business owners.

That pattern has a plain explanation. One agent with a person watching produces a volume of change that one reviewer can still read. Several agents running unattended produce more change for the same reviewer, and their changes can conflict.

Broader adoption figures do not answer this question. The US Census Bureau's Business Trends and Outlook Survey reports that firms with at least 20 employees are the biggest AI users. Its question covers AI use in any business function during the past two weeks, so it says nothing specific about agents or software development.

Does agentic dev make developers faster?

Agentic dev may make developers faster, but nobody has a settled figure. A randomised experiment is the kind of evidence to look for, and METR ran one, with 57 experienced open-source developers across 143 repositories and more than 800 tasks. METR itself calls the result an unreliable signal.

The reason matters. Between 30% and 50% of the developers said they withheld some tasks, so METR treats the result as a lower bound, not a firm effect size. It believes developers are likely sped up more than in early 2025. The participants were experienced open-source developers, which may not map onto a small team on a private codebase.

Surveys are weaker evidence, because they report what people say. Sonar's State of Code survey covers 1,149 people in technology jobs who coded or managed developers and had used AI at work in the past year. It is self-reported, and Sonar sells code quality and verification tools, so it has a commercial interest in how the findings land.

Speed on a task is also not speed to production. If an agent produces more change than a team can review, the queue simply moves to review. Measure the elapsed time from task to merged change, not the time until the agent stops.

What does agentic dev cost?

The seat is usually the small part of the cost of agentic dev. The larger part is the staff time spent specifying work and reviewing what comes back, and no pricing page shows that.

Anthropic's pricing page, read in November 2026, lists a Team plan Standard seat at $20 a month if billed annually, and the Team feature list includes Claude Code. That is one vendor's list price. It can change, and it excludes staff time.

For scale, the US Bureau of Labor Statistics gives $134,040 as the national median wage, as of May 2025, for a group covering software developers, QA analysts and testers. That is a wage, not the full cost of employing someone.

None of this means a seat replaces a person. The agent still needs somebody to scope its work and read its output, and that person's time is where the money goes. To estimate the real cost, count the specifying and review hours per change, then price those hours.

When is agentic dev not worth doing?

Agentic dev is not worth doing when there are no tests, nobody who can review the output, or no clear description of done. Without those, the agent's own report that it succeeded is all you have, and that is not evidence.

• •The repository has few tests. The loop has no reliable signal, so the agent stops when it believes it has finished.
• •Nobody on the team can read the code. A small business without a developer cannot review a diff, so the main safeguard is missing.
• •The change is small and you already know the fix. Writing and checking the task takes longer than making the edit.
• •A mistake is hard to undo. Payments, authentication and data migrations deserve a person at each step.
• •The real goal is not software. If you want invoices or requests handled automatically, you may need one workflow built, not a new development method.

What controls does agentic dev need?

Agentic dev needs five controls at minimum: a sandbox, narrow credentials, a required human review, checks the agent cannot edit, and a log of what it did. Each one assumes the agent will sometimes be wrong, and none of them depends on the model behaving well.

An agent reads untrusted text as part of its job: issues, web pages, dependency documentation, code comments. Any of those can carry instructions aimed at the agent, and a model has no dependable way of separating data from instructions. So the useful question is what the agent can reach if it is misled, not whether it will be.

• •Run it in a sandbox or a disposable environment, not on a machine holding production access.
• •Give it credentials scoped to the task, and keep secrets out of its environment.
• •Require a person to approve every merge, with no exception for changes that look small.
• •Keep the checks out of its reach, so it cannot edit a failing test or pipeline to make it pass.
• •Log its commands and file changes, so you can reconstruct what happened when a run goes wrong.