What is agentic coding?
Agentic coding is a way of working where you delegate tasks to a coding agent instead of typing the code yourself. You describe the outcome, the agent explores the repository, plans, edits and runs the tests, and you steer it, review the diff and verify the result. The skill moves from writing code to specifying and checking it.
Part of Glossary: the terms behind MCP, coding agents and shared pages, defined plainly.
Write the house rules once, in CLAUDE.md or AGENTS.md: the test command, style rules, what never to touch. The agent reads it at the start of every session.
Brief the task with a check the agent can run: the failing test, the screenshot to match, the command that must exit clean.
Let the agent explore and plan before it edits. For anything bigger than a one-line change, read the plan first.
Watch the first few steps, interrupt early when it heads the wrong way, and clear the context between unrelated tasks.
Review the diff and the evidence (test output, a screenshot), not the agent's sentence saying it is done. Then commit.
Anthropic's rule of thumb: if you can't verify it, don't ship it.
Source: Claude Code docs: Best practices
Agentic coding versus pair programming and vibe coding
Pair programming with AI meant turn-taking: you type, it suggests, you accept, repeat. Agentic coding changes who holds the keyboard. Anthropic's best-practices guide puts it as: instead of writing code yourself and asking for a review, "you describe what you want and Claude figures out how to build it." You still own the outcome; you just stop producing the keystrokes.
Vibe coding sits at the other edge: delegate everything, including the judgement. The difference is not the tool but the review. In agentic coding the diff gets read, the tests get run, and the commit has a human name on it for a reason.
Example: a feature from brief to pull request
You want expiry dates on share links. In plan mode, you ask the agent to read the link module and the existing settings UI and propose a plan. It comes back with four files to change and a question about what happens to links that already exist. You answer, approve the plan and let it implement. It adds a column, a migration, a date picker that follows the pattern of the other settings, and tests for the expired case. It runs the suite, pastes the output, and opens a pull request. You read the diff, ask it to rename one field, and merge.
Thirty minutes, most of it reading. The agent did the exploration, the typing and the first round of testing. You did the deciding: the brief, the plan review, the edge case it asked about, and the final read.
In practice: the habits that make it work
The guide's advice rests on one constraint: an agent's context window fills quickly and quality drops as it fills. Everything else follows. Keep CLAUDE.md short, because a long one gets ignored. Clear the context between unrelated tasks. After two failed corrections, start fresh with a better prompt rather than piling on a third. Push research into subagents so the file dumps stay out of your main session.
Give the agent a way to verify. A test, a build exit code, a linter, or a screenshot compared with a design turns "looks done" into "passes". Ask for evidence rather than assurances. For larger work, have the agent interview you and write a spec first, then run the implementation in a clean session.
Permissions are part of the craft. Pre-approve the commands you trust so the remaining prompts are worth reading, and use sandboxing when you want the agent to run without asking. When several people's agents edit the same artifact, the house rules move into the artifact itself, the way a shared board on Intraface carries a collab.md that every agent reads before publishing.
Common mistakes
- The kitchen-sink session. One conversation for five unrelated tasks. The context fills with noise and the agent forgets your rules. Clear between tasks.
- Correcting instead of restarting. Each correction leaves a failed attempt in context. Two is the limit; then rewrite the prompt.
- A bloated instructions file. Every line costs attention. Keep only what the agent cannot infer from the code.
- Trusting the summary. A plausible implementation that skips edge cases looks identical to a correct one in a chat message. Only the diff and the test output tell them apart.
- Scoping investigations as "look into X". The agent reads hundreds of files. Narrow the question or hand it to a subagent.
FAQ
- Is agentic coding the same as vibe coding?
- They share the tools and differ in the reviewing. Vibe coding means accepting what the agent produces as long as it appears to work, without reading the code. Agentic coding delegates the typing but keeps the engineering: a spec, a check the agent can run, a diff you read, a commit you stand behind. Same agent, different owner of the result.
- What tools do I need for agentic coding?
- A coding agent that can read, edit and run commands in your repository: Claude Code, Codex, Cursor's Agent, Gemini CLI, Copilot's agent mode and others. A test suite or another check the agent can run. An instructions file such as CLAUDE.md or AGENTS.md. Git, so that every agent change is a reviewable, revertible diff. Nothing else is required.
- Does agentic coding replace code review?
- It makes review more important, because the person reviewing is now the only one who did not write the code. Two habits help: have the agent show evidence (test output, the command it ran) instead of claiming success, and run a second agent with a fresh context to review the diff against the plan before you read it yourself.
Stop sending HTMLover Slack.
Create an account in a minute, connect your coding agent, and make your first board.