Agentic Coding: How Cursor, GitHub Copilot, and Claude Code Actually Work

Photo by James Harrison on Unsplash

Most people think agentic coding means autocomplete finally learned to finish the whole file. It doesn't. The shift feels familiar if you have watched Cursor rewrite a function, asked Copilot to handle a GitHub issue, or let Claude Code inspect a failing test, because the AI is no longer just suggesting the next line.

The real change is delegation with supervision. According to Cursor's official guide, agentic coding means building software by directing AI agents rather than manually writing every line, with the agent planning work, editing code, running commands, and checking results while the developer guides and reviews the work.

The agent is not the model

A language model does not edit your repository. It predicts text. The part that turns that text into a file change, a terminal command, a search query, or a pull request is the coding harness, and that distinction explains why two tools using similar models can behave nothing alike.

Microsoft's Visual Studio Code team made that separation explicit in its May 15, 2026 post on agent harnesses. According to Visual Studio Code, language models do not execute commands or alter files by themselves; the harness assembles context, exposes tools, runs the agent loop, interprets model requests, and translates them into editor actions.

That sounds abstract until you map it to something ordinary. Hiring a contractor to repair a kitchen is not the same as asking a friend for design advice. The contractor checks the room, chooses tools, calls specialists, inspects each step, and changes the plan when the wall hides bad wiring. AI coding agents work closer to the contractor model, except the developer still signs off on the work.

Visual Studio Code describes the agent loop as a think-act-observe cycle: the harness sends context to the model, executes requested tool calls, captures results, then returns those results to the model until no more tool calls remain. The same post lists example tools such as read_file, replace_string_in_file, apply_patch, run_in_terminal, and semantic_search, with tool definitions described through JSON schemas the model must follow, according to Visual Studio Code.

That is the under-discussed performance spec. Benchmark scores matter, but the agent's useful ceiling is often set by how accurately the harness gathers context, how safely it exposes tools, and how clearly it returns observations after each action. A brilliant model inside a clumsy harness is like a skilled contractor working from blurry photos and a locked toolbox.

Agentic coding is a harness problem, not a chatbot upgrade

Agentic coding is a workflow where a developer gives a software task to an AI system that can plan, inspect code, edit files, run commands, and evaluate results through a controlled tool loop. The model proposes actions, but the coding harness supplies context, enforces permissions, executes tool calls, and feeds results back for the next step.

Microsoft Research uses similar language at production scale. In its characterization of GitHub Copilot, Microsoft Research describes AI coding agents such as GitHub Copilot, Claude Code, and Codex as systems that interleave multi-step LLM inference with tool execution, creating a workload that differs from chatbot use.

The scale numbers are not small. Microsoft's study used sampled traces from June 2026 and covered 3.2 million users, 13 million sessions, 761 million LLM calls, and 95 trillion tokens, according to Microsoft Research. That is the technical reason agentic tools strain infrastructure differently from a chat window: one user request can expand into many model calls, code searches, patch attempts, test runs, and observations.

For readers trying to answer how do AI coding agents work, the shortest honest answer is this: the model decides what action it wants next, but the surrounding product decides what actions are possible. Cursor, GitHub Copilot, and Claude Code are not just skins over models. They are different tool systems with different permission models, review surfaces, and assumptions about where software work begins.

Cursor keeps you inside the editor, Copilot can leave a pull request

Cursor's version of the idea is editor-centered. According to Cursor, its agent can search code, edit files, and run terminal commands, then read each result before choosing the next step. Cursor also says Plan mode lets a developer review an approach before code is written, while Cloud Agents are meant for longer-running tasks that continue while the developer does other work.

That design creates a strong bias toward interactive steering. You can ask for a refactor, inspect the plan, reject part of it, and keep the agent close to the codebase you are actively reading. Cursor says agent usage in Cursor has grown more than 15x in the past year, according to its agentic coding guide, but the more revealing claim is not adoption. It is the workflow assumption: the agent is useful because it can repeatedly touch the real project, not because it can produce a polished answer in chat.

GitHub Copilot's cloud agent takes a different route. According to GitHub's responsible-use documentation, the Copilot cloud agent can pick up work from an issue, a pull request comment, or Copilot Chat, create a branch, generate tailored code changes, and open a pull request. That makes Copilot closer to an async contributor than a pair programmer sitting inside one editor session.

Cursor AI vs Copilot is not a clean model-quality contest. It is a difference in work shape. Cursor emphasizes direct editor supervision and iterative local context, while GitHub's cloud agent is built around repository tasks that can become branches and pull requests.

GitHub also describes a more constrained terminal path for Copilot CLI. According to GitHub, Copilot CLI can create and modify files, execute commands, and perform multi-step tasks, but its actions are scoped to the current directory and require explicit permission prompts before file changes or commands run. The product boundary is part of the safety model.

Claude Code shows the split: humans choose what, agents choose how

Anthropic's research gives the cleanest evidence that agentic coding does not remove the developer from planning. In a privacy-preserving analysis of about 400,000 interactive Claude Code sessions from about 235,000 people between October 2025 and April 2026, Anthropic found that humans made most planning decisions about what to do, while Claude made most execution decisions about how to do it.

That finding matters because it punctures the lazy version of automation anxiety. The tool is not mostly replacing the initial judgment of what should be built, at least in the usage Anthropic studied. It is taking over stretches of implementation detail after the user has framed the goal, narrowed the target, and accepted the risk of letting an agent act.

Claude Code vs GitHub Copilot also differs in where the studied activity happened. Anthropic says its study focused on Claude Code usage through the command-line interface, Claude.ai, or the Claude Code desktop app, and it reports that Claude Code users spend an average of 20 hours per week using the tool, according to Anthropic. GitHub's cloud agent, by contrast, is documented around issues, pull request comments, Copilot Chat, branches, and pull requests, according to GitHub.

Those surfaces train different habits. A command-line agent encourages you to ask for diagnosis, run a command, inspect the output, and continue. A pull request agent encourages you to describe a finished repository task and review the diff later.

The adoption numbers are real, but the quality ranking is not

Independent research suggests coding agents moved from novelty to meaningful adoption fast. The arXiv paper Agentic Much? Adoption of Coding Agents on GitHub studied 129,134 GitHub projects and estimated adoption at 15.85% to 22.60% of studied projects, calling that high for a technology only a few months old and increasing.

The same paper draws a useful line between coding agents and traditional code-completion LLMs. It describes coding agents as having higher autonomy, including the ability to generate complete pull requests from a developer-provided task description, and it found that agent-assisted commits were larger than human-only commits and included a high proportion of features and bug fixes, according to the arXiv study.

Larger commits are not automatically better. They are harder to review, easier to over-trust, and more likely to mix a real fix with unrelated cleanup. This is the hidden cost of delegation: the agent can compress the time it takes to produce a diff, but it can also expand the cognitive burden of proving the diff is safe.

A separate arXiv paper, Comparing AI Coding Agents, analyzed 7,156 pull requests from OpenAI Codex, GitHub Copilot, Devin, Cursor, and Claude Code. The study found no single agent performed best across every task type, which is the right way to deflate simplistic rankings.

The category results are more useful than a winner's podium. According to Comparing AI Coding Agents, Claude Code led documentation tasks at 92.3% acceptance and feature tasks at 72.6% acceptance, Cursor reached 80.4% acceptance on fix tasks, and OpenAI Codex had acceptance rates from 59.6% to 88.6% across nine task categories. Tool choice should start with the task, not the brand.

The risk is not only wrong code

Bad code is the obvious failure mode. The less obvious risks are provenance, permission, and environment trust. GitHub's cloud agent documentation says each cloud-agent session runs in an ephemeral development environment, a temporary isolated compute environment that is destroyed after the session ends, and that a firewall is enabled by default to prevent data exfiltration, according to GitHub.

Those controls are necessary because an agent with tools is not just answering. It is reading project context, modifying files, and sometimes running commands. If the environment is too permissive, a mistaken or manipulated tool call can turn a coding shortcut into a security incident.

GitHub documents a second risk that deserves more attention from teams using agents on proprietary code. According to GitHub, the Copilot cloud agent may generate code that is a match or near match of publicly available code even when the Suggestions matching public code policy is set to Block, and Copilot shows those matches in the agent session logs if that happens.

That complicating detail changes the review checklist. A human reviewer is not only checking whether the tests pass. The reviewer also needs to inspect provenance warnings, scan agent logs when they exist, and treat generated code as code with a chain of custody rather than anonymous text that appeared inside a pull request.

For teams building policies around AI Tools articles and developer workflows, this is where enthusiasm should slow down. Agent access should be scoped by repository, directory, command class, and data sensitivity. The safest agent is not the one with the most tools. It is the one with the least authority needed to finish a narrow task.

What to do differently when assigning work to an agent

A good agent task is closer to a ticket than a prompt. It should include the failure condition, the relevant files or subsystem, the expected tests, and the limit of acceptable change. Vague instructions produce broad diffs, and broad diffs punish reviewers.

A practical pattern is to split work by review risk:

1. Use agents for narrow fixes when the expected behavior is easy to test.
2. Ask for a plan before code when the task crosses architectural boundaries.
3. Prefer pull request agents for isolated repository issues with clear acceptance criteria.
4. Keep interactive agents close when you need to steer trade-offs sentence by sentence.
5. Treat generated diffs as untrusted contributions until tests, logs, and provenance checks say otherwise.

Cursor's Plan mode fits the second case because Cursor says it lets the developer review an approach before the agent writes code. GitHub's cloud agent fits the third case because GitHub says it can create a branch and open a pull request from a task that starts in an issue, pull request comment, or Copilot Chat.

For broader software coverage, AnIntent's Developer Tools articles and AI Infrastructure articles are the right places to track how these harnesses, permission systems, and model workloads change. The practical implication is already clear: stop judging coding agents as autocomplete with ambition. Judge them as junior contributors with tools, logs, permissions, and review obligations.