Course Challenge
Bring the four competencies together: a scenario-based knowledge check, then a capstone in which you take one real coding task through Delegation, Description, Discernment, and Diligence with Claude Code.
How the Challenge Works
The challenge has two parts:
- Knowledge check: ten scenario questions covering every module. Aim for at least 8 out of 10. If you miss one, read the explanation and revisit that lesson.
- Capstone task: take one real task from your own work through all four Ds with Claude Code, and keep a short log as you go.
This course is free and self-paced, so there’s nothing to submit. The goal is a way of working with agents that lasts longer than any particular feature.
Part 1: Knowledge Check
1. (Module 1) A teammate says Claude Code is 'just ChatGPT in the terminal.' What's the most important difference they're missing?
The agentic loop removes the automatic human checkpoint that copy-paste provided.
2. (Module 1) After a read-only 'explain the codebase' session, git status shows a modified file. What should you do?
An unexpected write during a read-only task is cheap to investigate now and expensive to discover later.
3. (Module 2) Which task should you NOT hand to the agent in high-autonomy mode?
Irreversible production actions need a human every time, regardless of how capable the agent is.
4. (Module 2) You keep clicking 'allow' for npm test fifty times a day. What's the fluent fix?
Good rules fix prompt fatigue without throwing away the checkpoint.
5. (Module 3) Your brief says 'make checkout faster.' The agent rewrites the cart UI. What was missing?
Without a measurable goal and a pointer to the real bottleneck, the agent guessed.
6. (Module 3) Every session, you remind the agent not to edit files in src/generated. Where should that instruction live?
Repeated facts go in persistent context. Must-never rules are best enforced by the harness.
7. (Module 4) The summary says 'all tests pass,' but git diff --stat shows a test file with 40 lines removed. What's your next step?
Gaming the check is a classic failure mode. The diff, not the summary, tells you what happened.
8. (Module 4) After an hour, the agent keeps alternating between two broken fixes. What's the best move?
Thrashing means the agent is missing information or has the wrong model. Stop the loop and diagnose together.
9. (Module 5) You ask Claude Code to summarize a third-party web page, in a session that also has your cloud credentials and an MCP tool that can send messages. What's the main risk?
Break the combination: run untrusted reading in a session without secrets or outbound tools.
10. (Module 5) A reviewer asks why your agent-written function handles the empty-list case that way, and you don't know. What does diligence call for?
That's the explain-it test. Your name on the commit means you own the reasoning, not just the keystrokes.
Part 2: Capstone, One Task Through the 4Ds
Choose a real, medium-sized task from your own work: a bug with a reproducible failure, a small feature, or a refactor of one module. Keep a short log in a text file as you go.
- Write the task in one sentence.
- Answer the three delegation questions: Is it verifiable? Is it sized for review? Is a mistake reversible?
- Decide which parts you’ll delegate, which you’ll do together (augmentation), and which you’ll keep.
- Choose a permission mode and any allow, ask, or deny rules for this task. Write down why.
- Create a branch (or worktree) and confirm a clean git state.
- Check that your CLAUDE.md has the exact test and lint commands. Update it if not.
- Write a four-part brief: goal, context (with
@file references), constraints, and done. - Start in plan mode. Review the plan with the Stage 1 questions from module 4 and push back at least once if anything is off.
- Log what you changed in the plan and why.
- Let the agent execute. Interrupt if it drifts, and log each interruption.
- When it finishes, run
git diff --statbefore reading its summary. - Read the full diff and check it against the failure-mode field guide from module 4.
- Run the key verification yourself.
- Ask a fresh session to review the diff skeptically. Log anything it found that you didn’t.
- Run your personal shipping checklist from the last lesson.
- Scan the diff for secrets, debug output, and unrelated changes.
- Pass the explain-it test for the riskiest part, or rework that part until you do.
- Open a small pull request with a human-written note on why the change is right and what was AI-assisted, following your team’s norms.
- Finish your log with one paragraph: what you’d do differently next time, and one line to add to your CLAUDE.md or standard brief.
About the Framework
The 4D AI Fluency Framework was created by Rick Dakan and Joseph Feller with Anthropic, and is released under CC BY-NC-SA 4.0. This course’s lessons, examples, and exercises are original.
Where to Go Next
- Discernment: Judging AI Output goes deeper on evaluating AI work of every kind.
- AI Fluency for Google Antigravity applies the same 4Ds to Google’s agent-first development platform. Comparing two agents’ design choices is a fast way to sharpen your judgment about both.
- AI Fluency for Leaders & Teams covers turning individual habits into team practice.