Live on Product Hunt Intraface launched today. Less steering, more vacations. See the launch
Start for free

What is a coding agent?

A coding agent is an AI agent whose tools work on a codebase: it searches and reads files, edits them, runs shell commands, tests and git, and reads the output to decide its next move. You describe the outcome, it does the work across as many files as needed, and you review the diff before anything ships.

Part of Glossary: the terms behind MCP, coding agents and shared pages, defined plainly.

How it works

A coding agent sits between you and the repository: it reads and edits files, runs tests in a terminal, and brings you a diff to review.on your machineor in a cloud VMyoucoding agentClaude Code, Codex, Cursoryour filesterminaltests, build, git1. the task2. reads, edits3. runs the tests4. output5. a diff to review
  1. You describe the outcome in plain words: "make the login tests pass" or "add a calendar widget that follows the pattern of the existing ones".

  2. The agent searches the repository and reads the files it needs, so it works from your code rather than from a guess about it.

  3. It edits files, then runs what you would run: the tests, the build, a linter, git. Each result comes back to it as text.

  4. It reads that output and continues. A failing test leads to another edit and another run, until the check passes or it gets stuck.

  5. A permission mode decides which edits and commands it may run without asking. You review the diff, then commit or discard.

    Claude Code and Cursor snapshot files as the agent edits, so you can rewind its changes without touching git.

Source: Claude Code docs: How Claude Code works

Coding agent versus autocomplete and chat

Three generations of AI help exist in editors, and they are easy to mix up. Autocomplete finishes the line you are typing. Chat answers a question about code you paste in. A coding agent is given a task and the means to finish it: tools for reading and searching files, tools for editing, and a shell. Anthropic's docs describe it as a loop of gathering context, taking action and verifying the result, with the model choosing which tool each step needs.

The shell is the detail that matters. Once an agent can run the test suite, the output of that run becomes its feedback. It no longer has to guess whether an edit worked; it can check. That is why agents handle multi-file changes that autocomplete never could, and why they need permissions that autocomplete never did.

Example: a flaky date test

You tell the agent that tests/billing.test.ts fails in CI but passes locally. It runs the test, sees it pass, and reads the test file. It notices a hard-coded date and greps for where the billing period is computed. It reads that function, spots a timezone assumption, patches it, adds a second test case that pins the timezone, and runs the suite twice. Both green. It shows you a diff of two files and the command output.

You did not point it at the function or tell it to add a test. You told it the symptom. The agent's job was to turn a symptom into a verified change; yours was to read the diff and decide whether the fix is the one you would have written.

Where it runs

Coding agents come in three shapes. A terminal agent, such as Claude Code or Codex CLI, runs in your shell against a local checkout. An editor agent, such as Cursor's Agent or the IDE extensions of the other two, shows diffs inline. A cloud agent runs in a virtual machine the vendor provides, starting from a prompt or a ticket and ending in a pull request; Cursor's cloud agents and the web versions of Claude Code and Codex work this way.

The shape changes what the agent can reach. A local agent uses your tools, your credentials and your files. A cloud agent gets a clean clone and whatever secrets you give it. Both can take MCP servers for tools beyond the repository, which is how an agent gets to a ticket tracker, a database or a shared board such as Intraface.

Common mistakes

  • Approving blind. After the tenth prompt, people stop reading. Pre-approve the commands you trust (the test runner, git status) so the remaining prompts are worth reading.
  • Giving the agent a vague symptom and no way to check. "The build is broken" gets a guess. Paste the error and name the command that must exit clean.
  • Treating the agent's snapshot as a backup. Checkpoints cover edits the agent made through its own tools. Commands that change files, and anything remote, are not covered.
  • Running with permissions off on a machine that matters. Every agent has a mode that skips approvals. Use it inside a sandbox or a throwaway environment, not on the laptop with your production credentials.

FAQ

Is a coding agent the same as code completion?
No. Completion predicts the next lines in the file you have open, and you accept or reject each suggestion. A coding agent takes a task, finds the files itself, edits several of them, runs the tests and comes back with a finished change. Completion sees your cursor; an agent sees your project and your terminal.
Can a coding agent run commands on my machine?
Yes, that is most of its value and most of its risk. Codex runs commands inside an OS-level sandbox that limits what they can write and reach. Claude Code asks before edits and shell commands in Manual mode and offers allowlists and sandboxing. Cursor's Agent executes terminal commands and monitors the output. Read your tool's permission settings before the first run.
Does a coding agent need an AGENTS.md or CLAUDE.md file?
It works without one, but a short instructions file is the cheapest improvement you can make. It is read at the start of every session and carries what the agent cannot infer from code: the test command, style rules, branch conventions, folders it must not touch. Claude Code reads CLAUDE.md and can fall back to AGENTS.md; most other agents read AGENTS.md.

Stop sending HTMLover Slack.

Create an account in a minute, connect your coding agent, and make your first board.