Agentic philosophy
Imagine it this way: The difference between a GPS that gives directions and a self-driving car. The GPS suggests; the car acts. Agentic coding is when AI doesn't just suggest: it acts, verifies, and corrects.
Agentic coding is a paradigm shift: instead of an assistant that answers questions about code, you have an agent that reads, edits, tests, and iterates on its own. You define the goal and constraints; the agent defines the path. It’s the difference between dictating every keystroke and delegating a task.
This isn’t futurism. It’s what Claude Code, Cursor, Windsurf, and other tools already do today. The plan and loop you learned in this track are the two fundamental gears of agentic coding. Plan mode is the strategic mind; loop mode is autonomous execution.
In one sentence: agentic coding = AI that acts, not just suggests. Plan and loop are the gears.
Effective delegation
Imagine it this way: A good manager doesn't do the work or hover over the team. They explain what's needed, set the rules of the game, and let the team work. It's the same with agentic AI.
The most important human skill in agentic coding is delegation. Good delegation means: (1) clearly defining the goal, (2) specifying the constraints (what must not change, which standards to follow), and (3) defining the success criteria (how to know when it’s done).
The most common mistake is going to either extreme: giving too much freedom ("improve the code") or too little ("on line 47, replace variable X with Y, then on line 52..."). The sweet spot is: a clear objective + clear constraints + freedom in how to achieve it.
In one sentence: effective delegation = clear objective + clear constraints + freedom in how to execute.
Review vs. micromanagement
Imagine it this way: You don't stand behind the chef saying, 'now add salt, now stir, now turn down the heat.' You taste the dish at the end. That's the difference between reviewing and micromanaging.
Review means looking at the result and evaluating whether it meets the goal. Micromanaging means controlling every intermediate step. In agentic coding, the temptation to micromanage is strong (you see Claude editing and want to intervene on every line). Resist. Let the loop finish and review the complete result.
Valid interventions: stop when you see something clearly wrong (editing the wrong file, loop going off course). Invalid interventions: interrupting because you 'would do it differently.' If the final result is correct and follows the constraints, the path doesn't matter.
In one sentence: review the result, not the process. Step in only when something is clearly wrong.
The autonomy spectrum: from fully manual to fully automatic. The sweet spot depends on the task and your confidence.
Old mindset
- - “I write every line”
- - “If I didn’t type it, it isn’t mine”
- - “AI is fancy autocomplete”
- - “Productivity = lines/hour”
Agentic mindset
- - “I define the goal and review”
- - “If it meets the constraints, it’s right”
- - “AI is a team member”
- - “Productivity = tasks/day”
Trust calibration
Imagine it this way: Trust is built through track record. The first time, you supervise everything. By the tenth time, you trust it and just check the result. The key is to calibrate trust with data, not gut feeling.
Start with close supervision (plan mode, review every step). As you gain experience with Claude in your project, gradually increase its autonomy. This is progressive: first a short loop with a few files, then a long loop with a larger scope, then a background agent.
Calibrate by domain: you can trust Claude with tests and linting (clear, automatic feedback) long before trusting it with architecture decisions (subjective feedback). Trust isn't global. It's specific to each type of task.
In one sentence: trust is progressive and domain-specific. Start supervised, scale up based on history.
Velocity metrics
Imagine it this way: Without a speedometer, you don’t know whether you’re speeding up or slowing down. Speed metrics show whether agentic coding is actually making you more productive.
Four metrics that matter: (1) tasks/day (how many tasks you complete per day), (2) time-to-merge (how long it takes from the start to merging the PR), (3) rework rate (how many times you need to fix what Claude did), (4) cost per task (how many tokens/dollars each task uses).
Don't obsess over metrics. They're a compass, not a destination. If tasks/day went from 3 to 8 but rework rate also increased, you're moving faster but with lower quality. Ideally, tasks/day increases while rework rate falls or stays the same.
In one sentence: tasks/day + time-to-merge + rework rate + cost per task. Metrics are a compass, not a destination.
The mindset shift
Imagine it this way: From pianist to conductor. The pianist plays every note. The conductor leads dozens of musicians. Both make music, but in fundamentally different ways.
The biggest obstacle to agentic coding isn't technical. It's mental. Programmers are used to typing every line and controlling every detail. The transition to "I define what to do and review the result" is uncomfortable. It feels like you're not working.
But you are. The work has changed shape; it hasn’t decreased. You now invest time in defining clear objectives, creating constraints, writing CLAUDE.md with project standards, reviewing diffs, and calibrating trust. This is higher-level cognitive work. It’s what scales.
In one sentence: from pianist to conductor. The work didn’t decrease. It changed levels.
What is effective delegation in agentic coding?
Module Summary
Track complete!
You completed Track 2. Next step: Track 3 — MCP Servers.