Agentic Coding: How Autonomous Agents Actually Ship Code

Agentic coding explained: the plan-edit-test loop, the autonomy ladder, where it FAILS and how to review agent PRs. Read the full guide.

Quick Answer: Agentic coding is software development where an AI agent runs the work loop on its own: it plans, edits files, runs the tests, reads the errors, fixes them and opens a pull request. It works when the agent has a real environment, a test suite that defines "done" and a human review gate before anything merges.


Agentic coding is the moment the AI stops suggesting code and starts shipping it. You give an agent a ticket. It reads the repository, makes a plan, changes a dozen files, runs the test suite, reads the stack trace, fixes its own mistake and comes back with a pull request.

That's a different job from autocomplete, and a different risk. This explainer covers the mechanism behind agentic coding: the loop every coding agent runs, the five rungs of autonomy from autocomplete to cloud agents, what makes it work, where it breaks and how teams review what agents produce.

We build cowork.ink, where each AI coworker has its own computer, browser and files. The same principle that makes coding agents useful is the one we apply to work that isn't code.


What is agentic coding?

Agentic coding is a way of building software where an AI agent pursues a goal through many steps, using real tools, until the goal is met or it gets stuck. The developer sets the goal and the constraints, then reviews the result.

The defining feature is the feedback loop. An autocomplete model predicts text and stops. A coding agent acts, observes what happened and decides what to do next. If a test fails, it reads the failure and tries again, without a person copying the error back into a chat window.

Anthropic describes Claude Code as an "agentic coding tool", and the term is now common across vendors. Agentic software development is the broader version: agents that also triage issues, update dependencies or fix failing CI.


How does agentic coding work? The loop

Every coding agent runs some version of the same six-step loop. The model is the reasoning part; the loop is what turns it into an engineer.

1
Read and plan

The agent searches the codebase, opens the relevant files and figures out the conventions, the test framework and how similar features were built. Many tools then write a plan, and some (Jules, for example) ask you to approve it before touching code.

2
Edit files

It makes changes across as many files as the task needs: the handler, the schema, the migration, the test. This is the part that looks like "AI writing code".

3
Run tests and commands

It runs the build, the type checker, the linter and the tests in a real shell. This is the step that separates an agent from a chatbot.

4
Read the errors

It reads compiler output, stack traces and failing assertions, the same evidence a developer would read.

5
Iterate

It fixes what broke and runs the checks again, repeating until they pass, it runs out of budget or it decides it needs a human.

6
Hand back a pull request

It commits to a branch and opens a PR, ideally with a summary of what it changed, what it ran and what it couldn't verify.

Steps 3 to 5 carry most of the value. Claude Code's own best-practices guide puts the failure mode bluntly: "Claude stops when the work looks done. If it has nothing to run that tells it whether the work actually is done, 'looks done' is all it has to go on. In practice that makes you the test suite."


The autonomy ladder: from autocomplete to cloud agents

Agentic coding isn't one product category; it's the top half of a ladder. Each rung moves one more part of the loop from the developer to the AI.

RungWhat the AI doesWho runs the loopExamples (as of November 2026)
1. AutocompletePredicts the next lines as you typeYouCopilot code completion, Cursor Tab
2. ChatAnswers questions, writes snippets you paste inYouChatGPT, Claude, Copilot Chat
3. In-IDE agentEdits many files and runs commands inside your editor, often asking before risky stepsThe agent, while you watchCursor agent, Copilot agent mode in VS Code
4. Terminal agentRuns the same loop in your shell; can also run headless in scripts and CIThe agent, on your machineClaude Code, Codex CLI
5. Background or cloud agentWorks on its own machine in the cloud while you're away and opens a PRThe agent; you review the PRCursor Cloud Agents, Codex cloud, GitHub Copilot cloud agent, Jules, Devin

Rungs 1 and 2 are assistance. Rungs 3 to 5 are agentic coding, and the jump from 4 to 5 matters most: the agent no longer shares your laptop, so it can run while you sleep and several can run in parallel. We cover that shift in background AI agents.

What agentic coding tools look like at rung 5

Here is what the main tools document about their own setup, as of November 2026:

  • Cursor Cloud Agents (formerly Background Agents): "Each agent runs in its own VM boundary." The agent pushes its branch and opens a pull request, and per Cursor's docs, "Nothing merges until a person reviews the change."
  • OpenAI Codex cloud: each task gets its own workspace that "can keep working while your computer is asleep"; you review the changed files, then commit or open a PR.
  • GitHub Copilot cloud agent (launched as the Copilot coding agent): works from an issue or prompt, pushes to a single copilot/ branch and opens a PR. Our GitHub Copilot coding agent guide walks through setup.
  • Google Jules: clones your code into a virtual machine, proposes a plan you approve, then lets you publish a branch or a PR.
  • Devin: works in its own shell, browser and editor, takes tasks from Slack, Teams or its web app, and leaves draft PRs for review.
  • Claude Code: Anthropic's "agentic coding tool" runs in the terminal, IDE, desktop app and browser; cloud sessions and separate git worktrees let parallel tasks run without colliding.

For a head-to-head on price, speed and fit, see Claude Code vs. Cursor vs. Devin vs. Windsurf.


Agentic coding vs. vibe coding vs. AI pair programming

The three differ in who runs the loop and whether anyone reads the code. They're often confused because all three involve typing English and getting code back.

AI pair programmingVibe codingAgentic coding
Who drivesThe developer types; AI suggestsAI writes; the person accepts by feelThe agent runs the loop toward a goal
Unit of workA line or a functionA prompt and a responseA task that ends in a PR
How code gets checkedThe developer reads each suggestionRun it and see if it seems to workThe agent runs tests and commands, then a human reviews
Does a human read the code?Yes, as it's writtenOften notYes, at the pull request
Where it runsYour editorA chat or app builderA real shell, often a machine of its own
Best forEveryday work in familiar codePrototypes and throwaway toolsScoped tickets, bug fixes, migrations with tests
Typical failureSlow; review fatigueCode nobody understands or ownsA confident PR that passes weak tests

The short version: AI pair programming keeps you at the keyboard, vibe coding removes the review, and agentic coding removes the typing but keeps the review. Read more about vibe coding and the AI-first workflow if prototypes are what you need.


What makes agentic coding work?

Three things: a real environment, a test suite that defines done, and a review gate. Take away any one of them and the agent is guessing.

  1. A real environment. The agent needs to install dependencies, run the build and start the app, not imagine what would happen. That's why rung-5 tools give each agent its own machine: it can run anything without touching your laptop or another agent's work.
  2. A test suite that defines done. Tests turn "looks right" into "passes". The best prompt for a coding agent often isn't a description of the code; it's "write a failing test that reproduces the bug, then make it pass."
  3. A review gate. A person reads the PR before it merges. CI runs on it. Branch protection applies to the agent the same way it applies to a junior developer.

There's a fourth ingredient that's easy to miss: a transcript. Good agents leave a record of every command they ran and every output they saw. Reviewing that record is faster than rerunning the checks yourself, and for a run nobody watched, it's the only evidence there is.

Claude Code's guide frames the setup as three questions worth asking before you delegate: does the agent know what done looks like, can it check its own work, and what is it allowed to touch? Our piece on agentic engineering goes deeper on building systems that answer those questions reliably.


Where does agentic coding fail?

Agentic coding fails where the loop has nothing solid to push against. Five patterns cover most bad agent PRs.

  • Ambiguous specs. "Improve the onboarding flow" gives the agent no test to pass. It will finish something, confidently, and it may not be what you meant.
  • Large refactors. The longer the task, the more the agent's early guesses compound. Changes that span many modules and need a design decision are better split into small tasks, each with its own check.
  • Flaky or thin tests. An agent iterates against whatever signal you give it. If the tests are flaky, it chases noise. If they're thin, it passes them without being right, and it may even loosen a test until it goes green.
  • Prompt injection. Agents read issues, docs and web pages, and any of those can contain planted instructions. Cursor's security docs name this risk directly: an attacker can plant instructions in content the agent reads and try to get it to send code to an external host.
  • Supply-chain risk. Agents install packages. In a study accepted to USENIX Security 2025, researchers generated 576,000 code samples and found that package names the models invented averaged at least 5.2% for commercial models and 21.7% for open-source ones. An attacker who registers a hallucinated name gets their code installed.
Benchmarks are not your repo

When SWE-bench launched in 2023, the best model it tested resolved 1.96% of its 2,294 real GitHub issues. Agents now score far higher on its curated subsets (current numbers are in our SWE-bench explainer). But a benchmark task comes with a known fix and a test that checks it. Your backlog usually comes with neither.


How should teams review agent PRs?

Review an agent's PR like a capable new hire's: assume it compiles, and check whether it's right. The habits that work:

  1. Read the transcript before the diff. What did the agent run? Did the tests actually pass, or did it say they would? Ask for evidence: the command and its output.
  2. Review the tests first. Check that new tests would fail without the change, and that no existing test was deleted, skipped or loosened.
  3. Check the scope. An agent asked to fix a bug that also "tidied up" four other files has made the review harder. Ask it to split the PR.
  4. Look at every new dependency. Confirm the package exists, is the one you meant and is maintained.
  5. Keep requester and approver separate. GitHub builds this in: its risks and mitigations page says the cloud agent can push to only a single branch, the person who asked for the PR can't approve it, and by default workflows "are not triggered until Copilot cloud agent's code is reviewed."
  6. Keep tasks small. Small PRs are faster to review and cheaper to throw away. Throwing one away should feel normal.

Teams that treat agent PRs this way get the leverage without the drift: the agent does the typing and the running, and a person still owns what ships.


The Same Principle, Beyond Code

Coding agents work because of three things they were given: their own machine, a check to run and a transcript of every step. None of that is specific to code. It's what any work needs when you hand it to someone you can't watch.

That's the idea behind cowork.ink: AI coworkers for the work that isn't code. Each coworker has its own computer, with a real browser, files, an inbox and a code runtime. It doesn't tell you how to pull the weekly report; it opens the dashboard, exports the data, builds the PDF and posts it in Slack or Telegram on the schedule you set. Every run is a transcript you can read and correct.

You set up as many coworkers as you need, in whatever roles you need, in about three minutes: say what it's for, hand it the context, connect Slack or Telegram and give it the first task. $25/month billed yearly, or $29 monthly, covering every coworker, its machine and the models. The engine underneath is GoGogot, open source under MIT, if you'd rather run it yourself.

Frequently Asked Questions

What is agentic coding?
Agentic coding is software development where an AI agent is given a goal and runs the work loop itself: it reads the codebase, plans, edits files, runs tests and commands, reads the errors, iterates and hands back a pull request. The developer sets the goal and reviews the result instead of writing each line.
What is the difference between agentic coding and vibe coding?
Vibe coding is prompting an AI and accepting the output if it seems to work, often without reading the code. Agentic coding gives the agent a real environment and a test suite, and the result still goes through human code review. Our guide to [vibe coding and the AI-first workflow](/blog/vibe-coding/) covers the other side.
What are the best agentic coding tools?
As of November 2026 the main agentic coding tools include Claude Code, OpenAI Codex, Cursor's agent and Cloud Agents, the GitHub Copilot cloud agent, Devin and Google Jules. They differ mostly in where the loop runs: in your editor, in your terminal or on a cloud machine of their own. We compare four of them in [Claude Code vs. Cursor vs. Devin vs. Windsurf](/blog/claude-code-vs-cursor-vs-devin-vs-windsurf/).
Is agentic coding safe?
It is as safe as the environment and the review gate around it. Run the agent in an isolated machine or branch, limit its network and secrets, make CI and tests mandatory, and never let the person who asked for the change be the only one who approves it.
Will agentic coding replace software developers?
Not on current evidence. Agents handle well-scoped tasks that have tests, but someone still has to write the spec, decide the architecture and review the pull request. The work shifts from typing code toward specifying, reviewing and owning it.
Home Blog Company