The graduation analogy
A first-year intern asks, "okay, what's the next line?" A senior engineer asks, "what's the goal?" — and disappears for an hour, returning with the implementation, tests, and a PR description.
Agentic coding is the same shift. Old AI tools wait for you to tell them every step. Agentic tools take a goal, plan the steps, act on the plan, observe the results, and iterate until done. You graduate from prompt-by-prompt to brief-by-brief.
The agentic loop in code
A coding agent runs the same observe → decide → act loop as any agent, with code-shaped tools:
- Read files, list directories, search for symbols.
- Plan — outline the change, identify the touch points.
- Edit files (preferably as diffs, not whole-file rewrites).
- Run tests, linter, type-checker.
- Observe the output. Fix what's red.
- Stop when the acceptance criteria pass.
The loop is generic. The "tools" are the developer toolkit you already have.
What changes about your workflow
Before (autocomplete era)
You write code. AI helps you finish lines. You manage the loop in your head.
After (agentic era)
You write a brief. AI manages the loop. You review the diff, run a sanity check, and merge — or send it back with notes.
The bottleneck shifts from "writing" to "specifying" and "reviewing." If you've ever managed a junior dev, you already have the skill.
Briefs that work, briefs that don't
A good brief has:
- Clear acceptance criteria — "tests pass," "lint clean," "API returns X for input Y."
- Scope boundaries — "do not touch the auth module."
- Constraints / conventions — "use repository pattern," "no new deps."
- A starting hint — pointers to relevant files or examples.
Bad briefs are vague — "make this better" — and produce vague work.
Where agentic coding shines
- Repetitive cross-file changes — rename, refactor, migration.
- Bug fixes with clear repro — "tests should pass with this input; they don't; fix it."
- Greenfield scaffolding — "implement this CRUD module per existing patterns."
- Tooling work — scripts, build config, infrastructure code that's well-trodden.
Where it stumbles
- Architectural decisions — agents pattern-match instead of reasoning about trade-offs.
- Sparse context — code with no clear convention, no tests, no docs. Agents drift.
- Long-horizon tasks without checkpoints — an unbounded loop spirals. Always cap turns.
- Cross-system invariants — "the DB schema and the GraphQL types must stay in sync" without a clear single source of truth.
The skills that matter now
- Spec-writing. Crisp acceptance criteria become the new craft.
- Code review. You'll review more diffs, faster. Sharpen your eye for subtle bugs.
- Test design. Agents iterate to green; great tests pull them in the right direction. Weak tests let them produce wrong code that "passes."
- Tool curation. Which MCP servers, which scripts, which hooks. Better tools = better agents.
What "more autonomous" should not mean
- No human review. Bigger blast radius needs more review, not less.
- No tests. Agents lean on tests; without them, you're flying blind.
- No conventions doc.
CLAUDE.md/AGENTS.mdis not optional in agentic flows. - No undo. Always work on a branch; agents make mistakes that you want to bisect easily.
In one line
Agentic coding rewires the day from "type code" to "spec, review, ship" — and the engineers who treat it that way out-ship the ones who don't.