Skill in Agentic Coding — The Agent Types, You Steer

Engineering Craft

The agent types. You steer.

Agentic coding tools can explore a codebase, plan a change, write the code, and run the tests. The developers getting outsized returns from them aren’t the ones with better models — they’re the ones with better steering.

↓ The working loop ↓ Skip to failure modes

Skill in agentic coding is not typing faster prompts. It is briefing, constraining, verifying, and cleaning up — four crafts nobody warns you about.

In this piece

The working loop
The four crafts
The tooling
Failure modes
Sources

Ali Reza Rashidi7 min readUpdated 6 August 2026

01—The working loop

Explore → plan → code → verify#

The biggest unlock is treating the agent like a strong junior colleague: you don’t hand them “fix the app” — you walk them through discovery, agree on a plan, and review their work like a pull request.

01ExploreLet the agent map the codebase before it touches anything. Read first, edit second.

02PlanAgree on the approach in words. A plan you approved beats code you didn’t expect.

03CodeSmall, reviewable steps — checkpoint before anything risky or multi-file.

04VerifyTests, builds, and your own eyes. Unverified agent output is a liability, not a deliverable.

55% faster task completion in controlled trials of AI pair programmers — GitHub

59% of developers now use three or more AI coding tools — Qodo, 2025

28% shipping confidence among developers juggling six or more tools — Qodo, 2025

4 phases in every healthy agentic session: explore, plan, code, verify

Where agentic sessions die

How to read this: notice what is not on this chart — model intelligence. Sessions die from steering failures: polluted context, skipped verification, vague briefs.

02—The four crafts

What “skill” actually means#

Four learnable disciplines separate the developers who swear by agents from the ones who swear at them.

“Fix the app” buys you plausible garbage. A strong brief reads like a ticket you’d give a sharp new colleague: the goal in one sentence, the constraints, and — most skipped of all — what done looks like.

Weak brief

“Make the checkout faster.”
“Add auth to the app.”
“Clean up this file.”

Strong brief

“Checkout p95 is 2.3 s; profile `payments.py`, cut the N+1 query, keep the API shape unchanged.”
“Add GitHub OAuth to `auth/`, mirror the existing session flow, tests in `test_auth.py` must pass.”
“Extract the three date helpers into `utils/dates.py`; no behavior change; run the suite.”

Every strong brief names

Goal: one sentence, observable.
Constraints: versions, style, files that are off-limits.
Definition of done: which tests pass, which behavior changes.
Context pointers: the files, commits, or docs that matter.

If a competent colleague couldn’t start from your prompt, neither can the agent.The model is not the bottleneck. The brief is.

CLAUDE.md, AGENTS.md, .cursor/rules, copilot-instructions.md — different logos, same idea: a file the agent reads before every session. It should contain what a new hire couldn’t guess: commands, conventions, gotchas. It should not contain your architecture memoirs.

CLAUDE.md

# Project context for the agent
## Commands
- test: `pytest -x` · build: `npm run build`
## Conventions
- TypeScript strict, no default exports
- never edit applied DB migrations
## Gotchas
- auth tokens live in sessionStorage, not cookies
- billing retries are NOT idempotent

Keep

Commands: how to test, build, lint — exactly.
Conventions: the rules a reviewer would enforce.
Gotchas: the traps that cost you a day to learn.

Cut

Anything obvious from the code: the agent can read.
Rules it keeps ignoring: sharpen or delete — dead rules tax every session.
History and rationale: that belongs in docs, not in the prompt budget.

A 400-token context file beats a 4,000-token one.Every line you add is paid for in attention — in every future session, forever. AGENTS.md is emerging as the cross-tool standard: write it once, keep it honest.

The failure that costs you is rarely the loud crash — it is the silent wrong answer: code that runs, looks right, and computes the wrong thing for three weeks. Verification is not a personality trait; it is infrastructure. The same skepticism applies to your own speed: in METR’s 2025 randomized trial, experienced developers on their own mature repositories felt about 20% faster with AI — while the clock measured them 19% slower. Verify the loop itself, not just the output.

Three layers of gate

Automated: tests, typecheck, lint — wired as hooks that run after every agent edit, not when you remember.
Structural: checkpoints before risky multi-file edits; git worktrees so parallel attempts never collide.
Human: read the diff like a PR from a talented intern. If you won’t review it, don’t generate it.

verify.sh

# after every agent edit, before you even look
npm run typecheck && npm run lint && npm test
# green = review the diff · red = the agent fixes, not you

A silent wrong answer costs more than a loud crash.Agents produce both with identical confidence. Tests, diffs, and checkpoints are the seatbelt — wear them on short trips too.

An agent that re-reads files it already read, repeats a mistake you corrected, or proposes a plan contradicting its own earlier decision is not broken — its context is polluted. Every dead end, every abandoned approach, every correction is still sitting in the window, taxing attention.

Signs of context rot

Re-reading files it already summarized.
Repeating mistakes you already corrected.
Contradicting decisions it made an hour ago.

The fixes

Compact or clear: cheaper than debugging a confused agent.
Subagents for side quests: keep the parent’s context clean.
One task, one session: a fresh session with a good brief beats a long session with a polluted one.

Correcting an agent in circles is a context problem, not an intelligence problem.If you’ve told it three times, stop arguing with autocomplete. Reset with a sharper brief.

03—The tooling

Same skill, different logos#

The crafts transfer; only the filenames change. Wherever your agent lives, it has a context file, a way to checkpoint, and a way to run checks.

Tool	Context file	Standout steering feature
Claude Code	CLAUDE.md	Subagents, hooks, and skills as structured extensions
Cursor	.cursor/rules (*.mdc)	Inline edit + chat split over a repo-indexed context
GitHub Copilot	copilot-instructions.md	Inline completions plus agent mode inside the IDE
Windsurf	AGENTS.md / .windsurfrules	Cascade flow with persistent codebase awareness
Open-source agents	AGENTS.md / CONVENTIONS.md	Model-agnostic, terminal-native, scriptable

Write the context file once, keep it honest.AGENTS.md is emerging as the cross-tool standard — one file every agent reads. Treat it like a Makefile for behavior: short, current, and enforced.

04—The failure modes

Five ways smart people get dumb results#

None of these are model failures. They are steering failures — which is good news, because steering is learnable.

1

The kitchen-sink session.

One endless thread for every task. Context rots, the agent contradicts itself, and the savings evaporate in debugging. One task, one session.

2

Correcting in circles.

If you’ve told it three times, the context is the problem. Reset with a sharper brief instead of arguing with autocomplete.

3

The bloated context file.

A 2,000-line CLAUDE.md is a tax on every session. Keep what changes behavior; delete the rest.

4

Trust without verification.

The agent is confident, not correct. Tests, diffs, and checkpoints are the seatbelt — wear them on short trips too.

5

Infinite exploration.

Exploring feels productive and writes nothing. Timebox discovery, then demand a plan.

The skill was never typing. It is judgment — briefing well, constraining wisely, verifying ruthlessly, and knowing when to start over.

05—Grounding

Sources#

The session-failure chart is an editorial model; the productivity numbers are measured. Here is where each comes from — including the one that contradicts the hype.

Peng et al. (2023) — The Impact of AI on Developer Productivity: Evidence from GitHub Copilot. Source of the “55% faster” figure: a controlled trial, but a single contrived task (a JavaScript HTTP server), 95 developers, GitHub-authored. Real, and narrower than the headline. arXiv:2302.06590
Becker, Rush, Barnes & Rein — METR (2025). The most rigorous independent test: an RCT with 16 experienced open-source developers and 246 real tasks in their own mature repos. AI tools made them 19% slower — while they believed they were ~20% faster. The strongest evidence on this page for the verification craft. arXiv:2507.09089
Qodo — The State of AI Code Quality 2025. Survey of 609 developers (June 2025): 82% use AI coding tools daily or weekly; 59% run three or more in parallel; teams juggling six or more report 28% shipping confidence. qodo.ai
DORA — State of AI-assisted Software Development 2025. ~5,000 professionals: adoption near-universal and self-reported productivity high, with organizational delivery metrics the honest benchmark. dora.dev
AGENTS.md. The cross-tool context-file standard referenced throughout: one file every agent reads, now supported across the major coding tools. agents.md

Ali Reza Rashidi

Ali Reza Rashidi, a Senior Data Scientist-Gen Al | Al Architect | MLOps with over ten years of experience, He is the author of three books that delve into the world of data and management.

Skill in Agentic Coding

The Feedback Loop!

Truth, Hypothesis, Law, and Scientific Theory

The agent types. You steer.

Explore → plan → code → verify#