Agentic coding: the agent does the labor. You do the engineering.

Three eras in five years. Autocomplete (Copilot-classic): the model finishes your line — you were still the one driving every keystroke. Chat: you paste code into a box, the model suggests, you copy back. And now agents: the model works in your repo — reads files it decides to read, edits what needs editing, runs the build, reads the failure, fixes it, and reports back.

The unlock isn't a smarter model wearing a new UI. It's the loop: act → observe → correct, with real tools. An agent that can run your tests can check its own work — and that single capability changes what you can safely delegate.

Strip the branding from any coding agent — CLI (Claude Code), IDE-native (Cursor), cloud-hosted — and you find the same three organs:

This anatomy explains the two universal failure modes. Agents fail when the context is wrong (didn't read the right files, missing conventions, stale assumptions) or when the loop runs unverified (no tests to check against, so errors compound silently). Nearly every technique below is a countermeasure to one or the other.

Every serious agent reads a standing instruction file from your repo — CLAUDE.md, AGENTS.md, Cursor rules. This file is the project's memory across sessions, and writing it well is the single best investment in agentic coding.

Two rules keep it working. Keep it lean — it's loaded into every session's context, so a bloated file taxes every turn (the attention budget again); push per-task detail into skills. And keep it true — a stale instruction file is worse than none, because the agent trusts it over the code.

The naive move is one giant prompt: "build the feature." The reliable move is the shape senior engineers already know:

Tests deserve special emphasis: they convert the agent's greatest weakness (confident wrongness) into a solved problem, because the loop can check itself against them. Test-first is agent-native development — write (or have it write) the failing test, then let it iterate until green.

Past the basics, coding agents grow three extension points — all instances of patterns you've seen elsewhere on this site:

The composition is the point: skills teach, subagents parallelize, hooks enforce. A well-tooled repo makes a mediocre prompt succeed; a bare repo makes a great prompt gamble.

Vibe coding — accepting AI code without reading it — got a bad name from people doing it in production. But it's better understood as a review dial you set per artifact:

Agents that read the web and run commands have a threat model. Three edges cut most often. Prompt injection: a malicious webpage, package README or issue comment can steer an agent that reads it — treat all fetched content as untrusted, and gate what an agent can do after reading the internet. Secrets: agents read environments and echo what they read — keep credentials out of repos and logs, and out of the files agents routinely open. Dangerous commands: sandboxes, allowlists, and human approval on anything irreversible (deploys, migrations, force-pushes) — the same bounded-autonomy design as any production agent.

Team-level, two norms keep quality from silently eroding: PR review standards don't relax for AI-authored code (if anything, watch for plausible-but-wrong more, rubber-stamp less), and the instruction file is a maintained artifact — reviewed in PRs like code, because it programs every future session.

Agentic coding is the daily practice; the disciplines underneath it are the theory: