Claude Code

Claude Code sits at the opposite end of the spectrum from autocomplete. Instead of suggesting the next few tokens, it takes a task description, explores the repository, proposes a plan, and then edits files and runs commands to carry it out. The agent loop is explicit: read, act, observe the result, revise.

The tool surface is the architecture

File reads and writes, shell execution, and search are built in; everything else arrives through Model Context Protocol servers. That keeps the core small and makes the integration story uniform — a Jira server and a Postgres server look the same to the model.

The consequence for anyone designing agent workflows is worth drawing out. Capability is added by configuration rather than by code, and the same MCP server works across every MCP-speaking client. You are not building an integration for this agent; you are building it once.

Subagents extend the same idea to context management. A long task that would otherwise fill the window with intermediate output can delegate the noisy part — a broad search, a survey of a subsystem — and receive only the conclusion. Context exhaustion is the practical ceiling on agentic work, and delegating is the main lever against it.

Where the loop converges and where it wanders

The loop works when there is an oracle. A failing test, a type error, a linter, a build that either succeeds or does not — these give the agent a signal it can act on without you, and the iteration genuinely converges.

Remove the oracle and it wanders. Asked to improve code quality with no measurable target, the agent produces a large plausible diff shaped by general convention rather than by your constraints, and there is nothing in the loop to correct it. The most reliable predictor of a good session is whether “done” is machine-checkable.

Practically, that means investing in the feedback signal pays more than investing in the prompt. A project with a fast, comprehensive test suite gets dramatically better agent output than one without, and the difference is larger than any prompting technique.

Autonomy and its controls

The autonomy level here is supervised by design. Permissions gate what the agent may do unattended, plan mode separates deciding from acting, and hooks let you intercept tool calls to enforce policy — refusing writes outside a directory, blocking a command, requiring approval for anything touching migrations.

Those controls exist because the threat model is real. An agent with shell access reading untrusted text — a dependency’s documentation, an error message, a fetched page — is a prompt-injection target. Run on branches, scope permissions deliberately, and keep production credentials out of any repository it can read.

Where it fits

Work that spans several files and needs verification between steps. Dependency upgrades, framework migrations, adding a test suite to untested code, and tracing bugs across service boundaries all play to its strengths. Long mechanical changes — renaming a concept across two hundred call sites, updating every handler to a new signature — are close to ideal, because the work is tedious, the correctness criterion is clear, and the agent does not get bored.

For single-line completions inside an editor, an IDE-resident tool remains faster; Cursor Agent covers that ground. For teams that need model portability or self-hosted inference, Aider occupies a similar terminal shape without the vendor tie. For fully autonomous ticket-to-pull-request work with no human in the loop, Devin is the more ambitious and considerably less predictable option.

Setup, permissions and practical workflows are covered in our Claude Code guide.