# What is agentic coding, and what makes its output safe to merge

> Agentic coding means AI agents plan, edit, test and fix code for a task. In 260 SHIP missions, gates outside the agent sent 46 runs back to be fixed.

- URL: https://letsship.ai/blog/what-is-agentic-coding
- Author: Önder Ceylan
- Published: 2026-10-15

Agentic coding is software development in which an AI agent plans a change, edits the code, runs the tests and fixes its own errors. A developer states the goal and checks the result, and the agent does the steps between. What the agent hands back is still a draft until something outside the agent verifies it. In SHIP's [SWE-in-a-team](https://letsship.ai/blog/swe-in-a-team) study, 46 of 260 agent runs needed that outside check to send the work back.

The numbers on this page come from SWE-in-a-team: 13 builder configurations with 20 tickets each, one run per ticket, in one repository. Cost is the API-equivalent at list price, not a bill.

## Separate agentic coding from assisted coding

A Google Cloud explainer is the top search result for the term. In it, "autonomous AI agents plan, write, test, and modify code with minimal human intervention" ([Google Cloud](https://cloud.google.com/discover/what-is-agentic-coding)). The same page sets it against assistants that "wait for a user to type code or ask a question". An agent gets a goal and does the steps itself.

The table puts three ways to code with AI side by side.

| What differs        | Assisted coding                 | Agentic coding                             | Vibe coding             |
| ------------------- | ------------------------------- | ------------------------------------------ | ----------------------- |
| Who writes the code | The developer, with suggestions | An agent, from a goal                      | An AI, from prompts     |
| Unit of work        | A line, a function, a question  | A task or an issue                         | A prompt and its result |
| Who runs the checks | The developer                   | The agent, then gates outside it           | Often nobody            |
| Who reads the code  | The developer, line by line     | A reviewer, then the person who accepts it | Nobody, by choice       |

The middle column has a weak point in its own definition. "Minimal human intervention" says how little a person does, but not who checks the work. An agent that runs its own tests checks the work against its own idea of the task.

## Compare agentic engineering with vibe coding

Agentic engineering is software work with coding agents in which people stay responsible for what the software does. Martin Fowler describes a change "where humans oversee LLM agents who generate the code" ([Agentic Engineering](https://martinfowler.com/bliki/AgenticEngineering.html), 21 May 2026).

His contrast with vibe coding is about who reads the code. In his words, "with vibe coding humans don't look at the code". With agentic engineering, "they are concerned with the code", and they often review it in detail.

In practice the two terms meet. Agentic coding names what the agent does, and agentic engineering names the discipline around it: the review, the tests and the decision to accept. In the United States, monthly searches for "agentic engineering" grew from 210 to 1,600 in twelve months (DataForSEO, October 2026).

## Read what the definitions leave to you

The definitions agree that a person must check agent output, and they leave the method to you. IBM's explainer says that "every generated output should be treated as a first draft that requires careful review" ([IBM](https://www.ibm.com/think/topics/agentic-coding)). It also asks teams to enforce testing requirements before a merge, and to log what agents do.

A developer who reviews every agent diff by hand becomes the bottleneck that the agent was meant to remove. The other option is a set of checks that run on every change without a person. They must not depend on the agent's own account of its work, and three properties make a check useful here:

* It runs outside the agent's session, so the agent cannot skip it or mark it as passed.
* It starts from a fresh context, so it judges the diff and the deployed app instead of the agent's summary of them.
* It sends a failure back with the reason, so the agent can fix the work and does not start again.

## Wrap the agent in gates it does not control

A SHIP mission puts each piece of work through a fixed line of stages. Each stage after the Builder adds a check that the builder agent did not write ([how a mission runs](https://letsship.ai/docs)). The table follows that line.

| Stage          | What it adds                                                                                        |
| -------------- | --------------------------------------------------------------------------------------------------- |
| Planner        | A plan from the request, the repository and the acceptance criteria, before any code exists         |
| Builder        | The change, made in an isolated sandbox, with your formatter, linter and tests run before it pushes |
| CI             | Your own pipeline as a gate. A failure goes back to the Builder                                     |
| Reviewer       | A read of the diff against the plan, with findings that block the merge and findings that do not    |
| Preview deploy | The change on a live environment, deployed by your own pipeline                                     |
| QA             | The acceptance criteria tested against that environment, with proof of what QA checked              |

The agents never hold your credentials. Each sandbox gets a scoped, single-use callback token, and SHIP keeps the real keys. Each role can also run on a different harness and model, so the reviewer can use a different model from the builder.

## Bound the loop that sends work back

A failed gate sends its feedback to the Builder, and the mission continues. That loop needs a limit, because a stuck agent tends to fail the same way each round. SHIP counts repetition: a mission stops after a gate fails the same way twice ([retry limits](https://letsship.ai/docs/configuration/retry-limits)). A ceiling of 25 Builder attempts sits above that as a backstop, and a gate that fails a different way each round counts as progress.

SWE-in-a-team measured how often the loop did its job. Of 260 runs, 214 passed every gate on the first try and 46 needed the loop. The loop corrected 40 of those 46 with no person involved, and 31 of them on the very next push ([SWE-in-a-team](https://letsship.ai/blog/swe-in-a-team)).

CI did most of the work. It raised the first objection on 27 of the 46 rejected runs, the Reviewer on 15 and the Tester on 4. Two builder configurations could not turn CI feedback into a build that passed. They repeated the same failure until the limit stopped them, and that is the point where a person should look.

## Price each accepted change

Cost per change is the spend of an agentic coding setup divided by the changes that were accepted, not the ones it opened. SHIP measures spend from the list price of the model that served each call, per mission and per stage. A single mission stops at $5 by default ([LLM credentials](https://letsship.ai/docs/getting-started/llm-credentials)).

In SWE-in-a-team, 250 of the 260 runs resolved. A resolved run reached Ready for Acceptance, and hidden tests that the builder never saw passed on its pull request. The table shows four of the 13 builder configurations, recomputed from the [per-run data](https://letsship.ai/data/swe-in-a-team-per-task.csv). Totals are API-equivalent at list price for the same 20 tickets.

| Builder model                | Harness     | Resolved | Total for 20 tickets | Per resolved ticket |
| ---------------------------- | ----------- | -------- | -------------------- | ------------------- |
| `deepseek/deepseek-v4-flash` | open-code   | 20 of 20 | $63.17               | $3.16               |
| `gpt-5.6-sol`                | codex       | 20 of 20 | $76.64               | $3.83               |
| `claude-sonnet-5`            | claude-code | 20 of 20 | $86.22               | $4.31               |
| `claude-opus-5`              | claude-code | 20 of 20 | $109.66              | $5.48               |

Across all 13 configurations, cost per resolved ticket went from $3.08 to $6.44. The builder is not always the stage that costs the most. On one CSV export ticket, the Tester cost $5.31 of a $7.23 mission, because it ran its whole check twice.

## Keep a person at the merge

Gates catch most failures, but not all of them. In SWE-in-a-team, 4 of the 260 runs passed CI, review and QA and still failed the hidden acceptance tests.

One was a ticket that asked for class reminders to be queued. The builder wired the live email provider into the request path, so the endpoint returned a 500 whenever no API key was present. The repository's own tests stayed green, and the Reviewer and the Tester both approved. The study's verdict was that it "built the wrong thing, correctly".

For this reason, a SHIP mission stops at the pull request and waits for you. Auto-merge is off unless you turn it on for a project or a mission ([human in the loop](https://letsship.ai/docs/configuration/human-in-the-loop)). A checkpoint after the Planner, the Builder or the Reviewer lets you read that stage's output before the mission continues.

For the full line of stages, and how to build one yourself, read [What is an AI software factory](https://letsship.ai/blog/what-is-an-ai-software-factory). For each stage of the loop in detail, read [Agentic SDLC, defined](https://letsship.ai/blog/agentic-sdlc).

## Questions

### What is agentic coding?

Agentic coding is software development in which an AI agent plans a change, edits the code, runs the tests and fixes its own errors. The developer states the goal and checks the result.

### What is the difference between agentic coding and vibe coding?

In vibe coding, the person does not read the code the AI writes. In agentic coding, an agent does the work in steps, and a person or a set of gates checks the result.

### What is agentic engineering?

Agentic engineering is software work with coding agents in which people stay responsible for what the software does. Martin Fowler describes it as humans who oversee the agents and often review their code in detail.

### Is agentic coding safe for production code?

Agentic coding output is a draft until checks outside the agent verify it. In SHIP's SWE-in-a-team study, 46 of 260 runs needed CI, review or QA to send the work back.

### How do you verify code an AI agent wrote?

Use gates the agent does not control. Your own CI, a reviewer in a fresh context and a tester on a live copy of the app each check the change. Then a person accepts the pull request.

### How much does agentic coding cost per change?

Divide what every stage spent by the changes that were accepted. In SWE-in-a-team, 13 builder configurations cost from $3.08 to $6.44 per resolved ticket, at API list prices.