Adoption Levels and Growing Your Skills
You’ve written specs, configured hooks, built quality gates, internalised the hard rules. Seven chapters of tools and processes. So — honest question: how much of it has actually stuck? Where are you sharp, and where are you still faking it a bit? That’s what this chapter is for. Not more tools. Just a clear-eyed look at where you are and what to focus on next.
Before you continue, complete the AI Fluency Framework course if you haven’t already. It introduces the 4D model — Delegation, Description, Discernment, Diligence — which is the judgment framework we’ll map onto the adoption levels below.
Course: AI Fluency Framework and Foundations — anthropic.skilljar.com/ai-fluency-framework-foundations
With the 4Ds fresh in your mind, this chapter maps those competencies onto four adoption levels. The goal isn’t to label yourself — it’s to see where your strengths are, where the gaps are, and what “good” looks like at each stage.
Don’t skip levels. Each one builds habits you’ll need for the next. If you’re senior and Level 1 feels basic — it probably is for you, but make sure the spec habit and the review-every-line discipline are genuinely there before you move on. If you’re newer and four levels feels like a lot, relax. The point is knowing what to practise, not racing to the top.
The four levels
Section titled “The four levels”Level 1: Assisted Coding
Section titled “Level 1: Assisted Coding”You’re here if: You use Copilot for autocomplete and occasionally ask Claude questions about your code. You’ve done Exercise 01 and maybe poked around a bit, but you haven’t delegated a real task end-to-end. Most of your AI use is what the AI Fluency course calls automation — the agent completes a specific, bounded task and you take it from there.
What to focus on:
- Get comfortable with Claude Code sessions — starting them, approving actions, knowing when to stop.
- Use Copilot’s inline suggestions and chat for quick questions and small fixes.
- Start writing one-paragraph descriptions before you start any task, even if you implement it yourself. This builds the spec habit before you need it.
- Ask Claude Code to generate tests for existing code. Low stakes, high learning.
The 4D picture at Level 1:
| Competency | Where you are | What to build |
|---|---|---|
| Delegation | Building platform awareness — learning what agents can do at all | Experiment broadly — try different task types, see what works and what doesn’t |
| Description | Basic prompts, learning what level of detail matters | Practice giving more context than you think you need |
| Discernment | Reading agent output, catching obvious errors | Build the habit of reading every line the agent produces |
| Diligence | Following the hard rules from Risks and Hard Rules | Understand why each rule exists, not just what it says. Remember: you own what the agent produces, not the agent |
Do this / Not that:
| Do this | Not that |
|---|---|
| Use Copilot Tab to accept good suggestions | Accept every suggestion without reading it |
| Ask Claude Code to explain unfamiliar code | Copy-paste from ChatGPT into your codebase without understanding it |
| Write a one-paragraph description before starting any task | Jump straight into coding |
| Ask Claude Code to generate tests for existing code | Skip tests because “the agent wrote the code so it must work” |
You’re ready for Level 2 when:
- You’ve completed at least 5 tasks using Claude Code interactively.
- You’re consistently writing brief descriptions before implementing.
- You’ve caught at least a few agent mistakes — you trust yourself to spot issues.
Level 2: Agent Mode
Section titled “Level 2: Agent Mode”You’re here if: You’re comfortable with interactive sessions and you’ve started writing specs (The Spec-First Workflow). You want to delegate more of the implementation. You’re moving from pure automation into augmentation — the agent is becoming a thinking partner, not just a task runner.
What to focus on:
- Use Claude Code for full feature implementation, not just tests and small tasks.
- Practice plan-then-execute: have the agent explain its approach before it starts writing code.
- Contribute to the project’s CLAUDE.md when you notice recurring agent mistakes (Context Files).
- Try running two parallel sessions on different tasks.
- Build and use hooks and custom commands (Hooks, Commands, and MCP Servers) to standardise your workflow.
The 4D picture at Level 2:
| Competency | Where you are | What to build |
|---|---|---|
| Delegation | You know which tasks to hand off vs. keep | Develop instincts for decomposition — how small is small enough? |
| Description | You write specs using the template | Learn to calibrate: when is a spec detailed enough? When is it over-specified? |
| Discernment | You catch mistakes during review | Start noticing patterns in agent mistakes — the same types of errors recur |
| Diligence | You follow the rules and update CLAUDE.md | Build the feedback loop — every review teaches the system something. Verify before you ship; your name is on the commit |
This is where the Description ↔ Discernment loop starts to feel real. You describe what you want in a spec, you evaluate the agent’s output, you refine the next spec based on what went wrong. Each cycle makes your descriptions tighter and your reviews faster. If you’re not consciously running this loop, you’re just hoping the agent gets lucky.
Do this / Not that:
| Do this | Not that |
|---|---|
| Ask for a plan before implementation | Let the agent start coding immediately on complex tasks |
| Break features into 2–4 atomic tasks | Give the agent the whole feature as one task |
| Start a new session when the agent goes in circles | Keep prompting a stuck session |
Use /compact in long sessions to maintain focus | Let sessions run unbounded until they degrade |
| Commit after each successful agent task | Let the agent make 20 changes in one uncommitted session |
You’re ready for Level 3 when:
- You can reliably decompose a feature into agent-completable tasks.
- You’ve updated the CLAUDE.md at least once based on agent behaviour.
- Your agent-generated PRs pass review on first or second attempt most of the time.
Level 3: PR-Based Delegation
Section titled “Level 3: PR-Based Delegation”You’re here if: You’re comfortable with agent mode and want to delegate tasks that run in the background while you work on other things. You’re stepping into agency — the agent works independently from an issue, and you evaluate the result asynchronously.
What to focus on:
- Write issues in the agent-delegation format (Templates and Quick Reference has templates for this).
- Use worktrees and cloud/background agents for background delegation.
- Set up branch protection rules that enforce review gates on agent PRs.
- Run 3–5 parallel tasks (mix of interactive sessions, worktrees, and cloud/background agents).
- Track which task types succeed and fail with agents — build your mental model of what’s delegatable.
The 4D picture at Level 3:
| Competency | Where you are | What to build |
|---|---|---|
| Delegation | You delegate confidently for familiar patterns | Expand the boundary — try delegating tasks you’re less sure about, in a safe environment |
| Description | Your specs are good enough for async delegation | Write specs that work without you being there to clarify — the agent has to get it right from the spec alone |
| Discernment | You review efficiently and catch subtle issues | Develop a risk-tiered review approach — not every PR needs the same depth (Quality Gates covers this) |
| Diligence | You maintain context files and follow processes | Think about the system — are we catching everything? Where are the gaps? Own the deployment: fact-check, check for bias, confirm it meets our standards |
The Description ↔ Discernment loop is faster now. Your specs are tighter because you’ve seen enough agent output to know where they go wrong. Your reviews are sharper because you know the patterns. The payoff: less rework, higher first-attempt merge rates.
Do this / Not that:
| Do this | Not that |
|---|---|
| Write detailed issues with acceptance criteria and file references | Write vague issues like “fix the login bug” |
| Set the agent to create a draft PR (not ready for review) | Let agent PRs auto-notify the whole team before you’ve glanced at them |
| Review the plan comment before the agent implements | Let the agent run unsupervised on complex tasks |
| Use separate branches with strict protection rules | Give agents write access to main or develop |
You’re ready for Level 4 when:
- You’ve successfully delegated 10+ tasks via background agents.
- Your delegation success rate (PRs merged without major rework) is above 70%.
- You’re maintaining clean CLAUDE.md files across your projects.
Level 4: Orchestrator
Section titled “Level 4: Orchestrator”You’re here if: You routinely run multiple parallel sessions, you maintain project context files, and other team members come to you with questions about agent workflows. You operate across all three interaction modes — automation, augmentation, and agency — and you’re choosing between them deliberately.
What to focus on:
- Run 5+ parallel sessions routinely (local worktrees, cloud sessions, and
/batch— Parallel Workflows covers these). - Design and maintain CLAUDE.md files and hooks across projects.
- Set up and maintain CI automation (Claude Code GitHub Action or GitHub Copilot for reviews, checks, and maintenance tasks).
- Mentor other team members through Levels 1–3.
- Track agent-specific metrics (delegation rate, review rework rate, cost per merged PR).
- Evaluate new tools and patterns as the landscape evolves.
The 4D picture at Level 4:
| Competency | Where you are | What to build |
|---|---|---|
| Delegation | You orchestrate multiple streams of work | Optimise the whole pipeline — where are the bottlenecks? Where does delegation break down? |
| Description | Your specs and context files are models for the team | Capture what works as reusable patterns (more on this in Phase 6) |
| Discernment | You catch architectural drift across PRs | Review at the system level — not just individual PRs but how they fit together |
| Diligence | You shape the team’s processes and standards | Drive continuous improvement — retros, metrics, process updates. Set the bar for transparency and accountability across the team |
Do this / Not that:
| Do this | Not that |
|---|---|
| Track delegation metrics (success rate, rework rate, cost per merged PR) | Assume it’s working because nobody complained |
| Mentor teammates through Levels 1–3 with pairing and review | Gate-keep agent access or expect people to figure it out alone |
| Update CLAUDE.md proactively when you spot a pattern across PRs | Wait until the pattern causes a bug in production |
| Say “this task isn’t ready for an agent” when the spec is weak | Delegate everything because you can |
The key failure mode at Level 4: don’t let this role be junior and untrained. Delegation at scale is closer to production change management than to autocomplete. Orchestration requires experience, judgment, and the authority to say “this task isn’t ready for an agent.”
Self-assessment
Section titled “Self-assessment”The AI Fluency course introduced the idea of rating yourself on each competency. Here’s a version calibrated to our workflow:
| Competency | Novice | Developing | Confident |
|---|---|---|---|
| Delegation | I’m not sure which tasks to give an agent | I delegate familiar task types; I’m cautious with new ones | I have a reliable instinct for what’s delegatable and I’m usually right |
| Description | My specs often need significant rework after seeing the agent’s output | My specs work most of the time; I’m learning what level of detail matters | I can write a spec that produces good output on first attempt for most task types |
| Discernment | I catch obvious errors but miss subtle ones | I catch most issues during review; I sometimes spot patterns in agent mistakes | I review efficiently, I know where to look harder, and I update the system when I find issues |
| Diligence | I follow the rules when reminded | I follow the rules consistently and update CLAUDE.md when I learn something | I help shape the team’s processes and I think about the system, not just my own workflow |
Be honest. Nobody is “Confident” across the board in the first few weeks. The point isn’t to score well — it’s to see which competency would benefit most from deliberate practice. If your Description is strong but your Discernment is lagging, spend extra time on reviews. If your Delegation is confident but your Diligence is spotty, focus on the feedback loop.
What “good taste” looks like
Section titled “What “good taste” looks like”As you progress through the levels, something harder to measure starts developing: taste. It’s the judgment that tells you this spec is tight enough, that PR needs a closer look, this task should stay manual. You can’t learn it from a checklist.
But you can recognise what it looks like in practice:
- At Level 1, good taste is knowing that an agent suggestion looks right but taking the time to verify it anyway.
- At Level 2, it’s knowing when a spec is detailed enough to delegate versus when it needs one more constraint.
- At Level 3, it’s knowing which PRs to review in depth and which ones a quick pass will cover — and being right about it.
- At Level 4, it’s seeing a pattern across three unrelated agent PRs and realising the CLAUDE.md needs a new “Do NOT” rule before the pattern becomes an architectural problem.
Taste comes from reps. Every spec you write, every PR you review, every time you update a CLAUDE.md — you’re building it. The AI Fluency Framework’s Description ↔ Discernment loop is the mechanism: you describe what you want, you evaluate what you get, you adjust. Over time, the adjustments get smaller because your descriptions get better.
Exercise 07 — 4D Self-Assessment
Section titled “Exercise 07 — 4D Self-Assessment”This one is about reflection, not code.
- What to do: Using the self-assessment table above, rate yourself on each of the four competencies (Novice / Developing / Confident). Be honest — this is for you, not for a performance review. Then identify your weakest area and write down one specific, concrete action you’ll take in the next week to improve it. Feel free to discuss your assessment with a teammate — compare notes on where you see yourselves.
- What to look for: Is there a pattern? Many people at this stage are stronger on Description (they’ve practised specs) than on Discernment (reviewing is harder to practise deliberately). If your Delegation score is low, go back to the decision table in The Spec-First Workflow and try delegating one task type you’ve been keeping for yourself.
- Common pitfalls: Rating yourself too high (“I catch everything in review” — do you? How would you know?). Rating yourself too low out of modesty (“I’m novice at everything” — if you’ve made it this far, you’re at least developing). Being vague about the improvement action (“get better at reviews” vs “spend 30 minutes reviewing an agent PR with a senior dev this week”).
- Reflection prompt: Which of the 4Ds do you think is hardest to develop? Why?
Putting it together
Section titled “Putting it together”The levels aren’t a ladder to climb as fast as possible. They’re a map that helps you build each capability before you need the next one. The 4D framework gives you a language for what’s actually developing as you progress — it’s not just “I use more tools,” it’s “my judgment about what to delegate, how to describe it, how to evaluate the result, and how to maintain the system is getting sharper.”
Next up: how the team’s rhythm changes as everyone moves through these levels. Ceremonies, estimation, metrics, and retros all look different when agents are part of the workflow.