Module 5: The Developer as Director — Human-Agent Collaboration

Description

You've reached the most important module of this guide. It's not the most technical — that was Module 02 (LLMs) and Module 03 (the agentic loop). It's not the most practical — that's Module 07 (the project). But it's the one with the most impact on your real productivity with coding agents.

Why? Because the most decisive factor in whether AI makes you more productive or slower isn't the tool you use, or the model, or the prompt. It's you. How you think about the relationship between you and the agent. When you trust and when you verify. What you delegate and what you do yourself. When you let the agent iterate and when you interrupt it.

The METR study (July 2025) demonstrated it: with the same tool, some developers were faster and others were slower. The difference wasn't in the software — it was in the developer. This module teaches you the frameworks that make the difference.

By the end of the 5 capsules, you'll be able to apply two complementary mental models, analyze the METR study critically, act as a circuit breaker, and create your own trust calibration checklist and delegation framework — concrete artifacts you'll use in your work and in the Module 07 project.

Where We Are in the Guide

Module 01: The paradigm shift                ✅ Completed
Module 02: How LLMs work                      ✅ Completed
Module 03: From chatbots to coding agents     ✅ Completed
Module 04: The agent's toolbox                ✅ Completed
Module 05: The developer as director          ← YOU ARE HERE
Module 06: The fundamental workflow
Module 07: Project: Build a mini-agent

This is Module 05 of 7. Modules 02-04 gave you the technical understanding: how LLMs work, what a coding agent is, what tools it has. Now we move from "how the agent works" to "how YOU work with the agent."

Module 06 will build on this to teach you the concrete workflow (Research → Plan → Execute → Validate). But first you need the mental models and the judgment that make that workflow work.

Why This Module Is the Most Important

Think about the difference between knowing how a car works and knowing how to drive:

Modules 02-04 (technical):
→ You know how the engine works (LLMs)
→ You know what the transmission is (the agentic loop)
→ You know what the pedals and the wheel do (tools)

Module 05 (this):
→ You know when to brake and when to accelerate
→ You know when to trust the GPS and when to use your judgment
→ You know when the car needs maintenance vs when you're driving badly

You can know every component of a coding agent and still use it ineffectively. This module closes that gap.

The data backs it up:

Data	Source	What it reveals
19% slower with AI (average)	METR Study, July 2025	The tool alone isn't enough
Perception: 20% faster	METR Study, July 2025	We don't know when AI slows us down
Only 3% highly trust it	Stack Overflow 2025	Gap between use and trust
45% of AI code with security flaws	Veracode 2025	Verification isn't optional

The pattern is clear: the tool works, but without the developer's judgment to direct it, the result is unpredictable. This module gives you that judgment.

The Same Feature, Two Developers, Two Results

To anchor the module, consider a real case (based on documented patterns, the names are illustrative):

Task: Implement the processing of a new payment method in production. Deadline: 2 days.

Developer A — "Vibe operator"

Day 1, 09:00 → Asks the agent: "Implement the complete payment flow
                with Stripe for our app."

Day 1, 11:00 → The agent delivers 600 lines. It compiles. Developer A accepts.

Day 1, 14:00 → Runs the tests the agent generated. They pass. Developer A
                accepts.

Day 1, 16:00 → Opens a PR. The manager asks for minor style changes. Applies them.
                Developer A accepts each of the agent's suggestions without reading.

Day 2, 10:00 → PR approved, merge to main, deploy.

Day 2, 16:00 → INCIDENT: the flow applies the discount AFTER charging
                the full amount, not before. 47 transactions affected.
                Remediation cost: ~50K USD between refunds and support.

POSTMORTEM:
- The agent generated plausible code but with an order-of-operations bug
- The tests were also generated by the agent — they tested the incorrect flow
- Developer A accepted "because it passed the tests" (the agent's own)
- Nobody was a "circuit breaker" between generation and production

Developer B — Applies the Module 05 frameworks

Day 1, 09:00 → Same task, same agent.

Day 1, 09:30 → Before generating code, writes a mini-spec by hand:
                what order the operations should run in (discount BEFORE
                charging), what edge cases (partial refund, currency
                mismatch). Mental model: "intern manager — I don't tell it
                'do it', I give it the spec".

Day 1, 11:00 → The agent delivers 600 lines. Developer B applies
                CIRCUIT BREAKER #1: reads the complete code, not just
                runs the tests. Finds the order-of-operations bug.
                Reports it to the agent and asks for the fix.

Day 1, 13:00 → The agent's tests pass. Developer B applies
                CIRCUIT BREAKER #2: the agent tested ITS code, not the
                business logic. Writes 4 additional tests based
                on the original spec. One fails — the partial refund one.
                Iterates with the agent.

Day 1, 16:00 → Opens a PR. Applies TRUST CALIBRATION before merging:
                "Does this touch real money?" Yes → reviews each modified line
                manually, not for style, for correctness.

Day 2, 10:00 → Deploy.

Day 2, 16:00 → Zero incidents. Developer B documents the pattern in
                CLAUDE.md for future payment features.

Same agent. Same problem. Same timeline.

The difference wasn't the tool. It was:

Having a clear mental model (Capsule 02: intern manager > "AI colleague")
Knowing the METR study's perception gap (Capsule 03: the agent can be "almost right")
Applying a circuit breaker at specific points (Capsule 04)
Calibrating the level of verification based on the risk (Capsule 04: trust calibration)
Deciding what to delegate and what to do manually (Capsule 05)

The 5 capsules of this module train you to be Developer B instead of Developer A.

Prerequisites

Required knowledge:

✅ Modules 01-04 completed (you understand the context, LLMs, the agentic loop, and tools)
✅ Having used some AI coding tool at least a few times (to connect the mental models with your experience)

NOT required:

❌ You don't need to be an expert in any specific tool
❌ You don't need to know the formal workflows (that's Module 06)

Module Roadmap

This module has 5 progressive capsules:

Capsule 01 — Module introduction (this capsule)

Context, prerequisites, and roadmap. Why the developer is the most important factor. The case of the two developers.

Capsule 02 — Mental models: power tool and intern manager

Two complementary frameworks for thinking about your relationship with agents. "Power tools, not teammates" (agenticoding.ai): the agent is a tool you operate, not a colleague. "Managing an intern" (MIT Missing Semester): the agent does the work, you validate with professional judgment. How and when to apply each model.

Capsule 03 — METR study and productivity data

Complete analysis of the METR study: methodology, main findings, the perception gap, the study's limitations, the February 2026 update, and the transcript analysis. What this data means for your daily practice.

Capsule 04 — Circuit breaker and trust calibration

The concept of AI as an amplifier of patterns (good AND bad). The developer as a "circuit breaker" — when to intervene and when to let the agent work. A trust calibration framework: what to always verify, what to verify partially, what to accept with confidence.

Capsule 05 — When to delegate and when to do it yourself

A practical decision framework. Classification of tasks: delegable, partially delegable, non-delegable. The cost of "almost right." Signs that you should stop using AI for a task.

Progression map

Capsule 01 (this)     → Context: why YOU are the key factor
Capsule 02            → The frameworks: how to think about the relationship
Capsule 03            → The evidence: what the data says
Capsule 04            → The practice: when to intervene, what to verify
Capsule 05            → The decision: what to delegate, what not

Difficulty: ⭐⭐ ────────────────────────▶ ⭐⭐⭐

What connects each capsule

Capsule 01 → "YOU are the deciding factor" (motivation)
     │
     ▼
Capsule 02 → "This is how you should THINK about the relationship"
     │        (mental models: power tool + intern manager)
     ▼
Capsule 03 → "This is what the DATA says happens"
     │        (METR study, perception gap, limitations)
     ▼
Capsule 04 → "This is how you ACT in practice"
     │        (circuit breaker, trust calibration)
     ▼
Capsule 05 → "This is how you DECIDE what to do yourself and what to delegate"
             (decision framework, task classification)

The progression is: motivation → frameworks → evidence → action → decision. Each capsule gives you a piece of the puzzle. By the end of the module, you have a complete system for working with coding agents professionally.

What You'll Achieve in This Module

By completing the 5 capsules, you'll be able to:

Apply the "power tools, not teammates" mental model — understand that the agent is a tool, not a colleague
Use the "intern manager" model — give clear instructions, verify the result, give specific feedback
Analyze the METR study critically — data + context + limitations + implications
Act as a "circuit breaker" — know when to intervene and when to let the agent work
Create your trust calibration checklist — what to always verify, what to accept with confidence
Classify tasks — delegable, partially delegable, non-delegable
Recognize signs that AI is slowing you down instead of helping you

The before and after

BEFORE the module:
→ "AI is my copilot — I trust what it generates"
→ "If it works, I accept it"
→ "I don't know when AI slows me down vs helps me"
→ "I delegate everything I can to AI"

AFTER the module:
→ "AI is a power tool that I operate with judgment"
→ "I verify based on the risk of the task"
→ "I know the signs that AI is slowing me down"
→ "I know exactly what to delegate and what not"
→ "I have a decision framework, not just intuition"

What This Module Does NOT Cover

Topic	Where it's covered
The concrete R→P→E→V workflow	Module 06
How to write effective prompts	Prompt Engineering guide
Specific tools (Claude Code, Cursor)	Specific-tool guides
How to build agents	Module 07 (the mini-agent as a learning exercise)

This module is about the developer's judgment and decision frameworks. The concrete workflow comes in Module 06. First you understand how to think — then you learn the process.

Connection with the Final Project

In Module 07, you'll build a mini coding agent and observe how it makes decisions. For that analysis, you need the frameworks of this module:

Trust calibration — to evaluate when your mini-agent gets it right and when it fails
Circuit breaker — to identify at what point you should intervene as a human
Mental models — to articulate the relationship between your intent and the agent's actions
Decision framework — to classify which tasks your mini-agent handles well vs badly

Your "circuit breaker protocol" and your "trust calibration checklist" (which you'll create in capsules 04-05) are direct tools for the project analysis.

Key Concepts of This Module

Power Tool

A coding agent isn't a colleague that "understands" your project. It's a powerful tool you operate — like a jackhammer, an electric saw, or a CNC lathe. The tool amplifies your capacity, but the direction, the judgment, and the responsibility are yours. Capsule 02 goes deeper.

Intern Manager

Think of the agent as a talented but inexperienced intern. It can do work fast, but it needs clear instructions, supervision, and specific feedback. You don't tell it "do the project" — you tell it "implement this function with these criteria." Capsule 02 goes deeper.

Perception Gap

The difference between how productive you THINK you are with AI vs how productive you REALLY are. The METR study found a gap of ~39 percentage points. Capsule 03 analyzes why it happens and how to handle it.

Circuit Breaker

Your role as a developer is to be the "circuit breaker" — the mechanism that stops a chain of errors before it reaches production. AI generates code fast, but it can generate errors just as fast. You're the point of verification. Capsule 04 goes deeper.

Trust Calibration

A framework for deciding how much to verify an agent's output, based on the type of task, the risk, and your experience with the tool. Not everything requires the same verification — the trick is knowing what does and what doesn't. Capsule 04 goes deeper.

Traps to Avoid While Taking This Module

Five predictable misunderstandings. Anticipate them before starting.

1. "Trust calibration means always distrusting"

No. Trust calibration is gradation: high trust for low-risk tasks and well-established patterns, low trust for high-risk or ambiguous tasks. Distrusting everything makes you as slow as doing it manually — it cancels out the agent's advantage. Capsule 04 gives you a concrete framework to calibrate, not a vote in favor of paranoia.

2. "Power tool, not teammate" means robotizing the work

It's the opposite. The "power tool" framing recovers your role as an operator with judgment. A CNC lathe doesn't decide which part to make — the operator does. If you treat the agent as a teammate, you cede decisions that are yours. If you treat it as a power tool, you take back control. Capsule 02 develops it.

3. "The METR study proved that AI makes us slower, period"

No. The METR study showed that without methodology, developers were 19% slower in their specific context (16 devs, open source tasks, early-2025 agents). The study has explicit limitations — sample size, task distribution, tools that have already changed. Capsule 03 gives you the complete analysis: data + methodology + limitations + implications, not the headline.

4. "The circuit breaker slows me down"

In the short term, yes. In the medium term, it saves you the 50K of Developer A's incident. The circuit breaker isn't a brake — it's a calibrated point of verification. Capsule 04 teaches you where to place them to minimize friction and maximize protection.

5. "I want a universal delegation framework"

There isn't one. What you delegate depends on the risk of the task, your experience with that part of the code, the project context, and the agent's maturity. Capsule 05 gives you the axes of the framework — risk, familiarity, ambiguity — but the final decision is contextual. Don't expect a single checklist; expect a decision model you apply case by case.

Diagnosis: What's Your Starting Point?

Five reflective questions. Connect each one with your real experience before starting.

Question 1: The last time you used a coding agent, was there a moment when you accepted something "because it looked fine"?

If yes: note the case. Capsule 04 (trust calibration) gives you the framework to have decided differently. It wasn't your intuition that failed — it was the lack of an explicit criterion.

If you don't remember: it probably happened but you didn't register it. Capsule 04 trains you to detect those moments.

Question 2: Do you feel you're faster with AI than without AI? How would you measure it?

If you said "yes, clearly": read the METR study before Capsule 03. The perception gap is one of the most important findings — developers felt 20% faster while being 19% slower.

If you said "I'm not sure": you're in a better position than most. Capsule 03 gives you the method to measure it in your context.

Question 3: Is there a task in your work where TODAY you know you should NOT use AI? Why?

If yes: note your reasoning. Capsule 05 gives you a framework to articulate it formally and apply it to other tasks.

If not: consider why. You probably delegate more than you should. Capsule 05 gives you the axes (risk, familiarity, ambiguity) to identify where delegation slows you down.

Question 4: What's the last thing you check before merging code generated by an agent?

If you have a clear answer: is it the same verification for all tasks? Capsule 04 helps you graduate it by risk.

If you don't have an answer: this is the main output of the module. You'll come out with a checklist of your own.

Question 5: Do you get frustrated with the agent when it doesn't understand something? Why?

If yes: the frustration usually comes from treating it as a teammate ("it should understand") instead of a power tool ("I direct it"). Capsule 02 explains why the reframe matters.

If not: how do you frame it mentally? If it's "it's just a tool," you're on the right track. Capsule 02 formalizes that instinct.

If you hesitated on 3 or more: this module saves you Developer A's incident. If you answered them all with clear judgment, use it as a review focused on Capsule 03 (the METR study), which almost no one reads in depth.

How to Work Through This Module

Recommendation:

Capsule 02 is fundamental. The mental models define how you think about AI. Without them, capsules 03-05 are techniques without context.
Capsule 03 requires critical thinking. Don't stop at the headline of the METR study — understand the methodology, the limitations, and the implications.
Capsules 04-05 are practical. Create the artifacts that are asked for (trust calibration checklist, task classification). You'll use them in Module 07.
Connect with your experience. Each concept is understood better if you relate it to real situations from your work.

Estimated time:

Capsule 01 (this)  →  5 min reading
Capsule 02         → 10 min reading
Capsule 03         → 12 min reading + analysis
Capsule 04         → 10 min reading + exercises
Capsule 05         → 10 min reading + exercises

Total: ~50-60 minutes

Evidence of Success

Before moving on to Module 06 (The fundamental workflow), you should be able to:

✅ Articulate the two mental models (power tool, intern manager) and when to apply each
✅ Summarize the METR study with data + methodology + limitations (not just the headline)
✅ Identify at least 3 points where you'd place a circuit breaker in your current flow
✅ Have written your own trust calibration checklist (what to always verify, what to accept with confidence)
✅ Classify 10 real tasks from your work as delegable / partially delegable / non-delegable
✅ Recognize at least one personal sign of "AI is slowing me down right now" (the perception gap applied)

If any aren't met at the end, go back to the corresponding capsule. Module 06 (the R→P→E→V workflow) builds on these artifacts — without them, the workflow is an empty process.

Summary

This module is the heart of the How Coding Agents Work guide.

What it covers:

Mental models for the developer-agent relationship (power tool + intern manager)
Complete analysis of the METR study with context and limitations
The developer as a circuit breaker — AI amplifies patterns, good and bad
A trust calibration framework — what to verify and what to accept
A decision framework — what to delegate and what to do yourself

What it produces:

Professional judgment for working with any coding agent
Your personal trust calibration checklist
Your circuit breaker protocol
Your task classification (delegable / partially delegable / non-delegable)

Why it's the most important module:

The tool without judgment is unpredictable (METR: 19% slower)
Judgment without the tool is slow but reliable
Judgment WITH the tool is fast AND reliable
This module gives you the judgment
The difference between Developer A and Developer B in the opening scenario is exactly what this module teaches

Next capsule: 02 — Mental models: power tool and intern manager — two complementary frameworks for thinking about how you work with coding agents. We start here because without the right mental model, the METR study data (Capsule 03) and the circuit breaker practices (Capsule 04) don't fall into place.

Additional Resources

Agentic Coding — Mental Models — The "power tools, not teammates" framework with examples and data
MIT Missing Semester 2026: Agentic Coding — Where the "managing an intern" model is introduced
METR Study: Early 2025 AI-Experienced OS Dev Study — The complete study that capsule 03 analyzes
METR Exploratory Transcript Analysis — Analysis of how agents make decisions
Anthropic: Claude Code Best Practices — Recommended practices that reflect these mental models
Stack Overflow Developer Survey 2025: AI Section — Trust and usage data that contextualizes trust calibration
Veracode: 2025 State of Software Security — The data point of 45% of AI code with security flaws

← PreviousConfiguration and Permissions: CLAUDE.md, .cursorrules, AGENTS.md, and Sandboxing Next →Mental Models: Power Tool and Intern Manager