Anthropic launched Claude Academy this week — a learning hub with courses, tutorials, badges, and personalized recommendations built around three verbs: delegate, verify, learn. My first reaction was mildly cynical — another vendor education portal — until I compared it against how most engineering orgs I know actually rolled out AI tooling to their teams, which is: buy the seats, send a Slack message, done. Nobody trained anyone on when not to delegate, or what “verify” is actually supposed to look like beyond “read the diff.” That gap is real, it’s costing teams more than the seat licenses, and a formal curriculum existing now — whether or not you use Anthropic’s specific one — is a good excuse to fix it deliberately instead of by osmosis.
The gap isn’t tool access, it’s judgment
Every team I’ve talked to this year has near-universal Claude Code or Copilot adoption. Almost none of them have a shared answer to: when is delegating a task to an agent the right call, versus when does it cost more than doing it yourself? That’s not a trivial question — a LeadDev piece earlier this month made the point sharply that AI-generated code can be entirely correct and still cost more downstream, because it lacks codebase context that shows up later as extra review threads and comments. If your team doesn’t have a shared mental model for when delegation pays off, you get the worst version of adoption: everyone delegating everything, all the time, because nobody was taught the boundary.
“Verify” has the same problem. Most engineers I’ve watched review AI output either rubber-stamp a diff that looks plausible, or over-correct into re-reviewing every line as if the AI wrote nothing trustworthy — neither is a calibrated skill, both are what happens when nobody taught the middle ground.
What a curriculum actually needs to cover
Whatever platform you use, the content that closes this gap is roughly the same. I’d structure it as four tiers, not one flat course:
Tier 1 — Fundamentals (everyone, week one). What the tool is actually good at versus bad at, in your specific stack — not generically. A generic “AI is good at boilerplate” slide is useless; “our AI is good at writing test fixtures for our ORM, bad at reasoning about our specific race condition in the queue worker” is useful, and it has to come from your own senior engineers, not a vendor deck.
Tier 2 — Delegation judgment. Concrete scenarios: here’s a task that took 10 minutes to delegate and verify versus 45 minutes to do by hand — worth it. Here’s a task that took 5 minutes to delegate and 90 minutes to untangle because the agent lacked context it had no way of knowing it needed — not worth it, and here’s the tell you missed. This tier is the one nobody writes because it requires collecting real internal failure cases, not hypotheticals.
Tier 3 — Verification discipline. The specific, mechanical habits: what’s the minimum diff review process for AI-authored code versus human-authored code (should not be identical — arguably should be more scrutiny on architecture-level decisions and less on style, since AI rarely gets style wrong). Tie this directly to the MCP and tool-security discipline your team already has, if it does — verification isn’t just “does the code work,” it’s “did this agent call anything it shouldn’t have.”
Tier 4 — Champions, not mandates. The teams that get this right don’t run this as a top-down compliance module. A LeadDev piece on grassroots AI adoption made the point well: mandate-driven rollouts get compliance theater, champion-driven rollouts get actual practice change, because a peer showing you their real workflow lands differently than a training video.
Rollout sequencing that avoids the usual failure
The usual failure mode is running Tier 1 for everyone at once and calling it done. A sequence that’s worked better in practice:
- Two or three senior engineers go through the material first and write the internal, stack-specific version of Tier 1 and Tier 2 — the vendor curriculum is a scaffold, not the final content.
- Roll out to one team, not the whole org, and treat the first cohort’s feedback as required input before wider rollout — not optional.
- Identify champions from that first cohort by who’s already organically helping teammates, not by asking for volunteers.
- Track adoption by outcome, not attendance — review-thread counts on AI-authored PRs, time-to-merge, incident rate tied to agent-authored changes. A badge earned in a course tells you nothing about whether judgment actually improved.
The actual point
A formal AI literacy platform existing is a signal, not a solution. The content still has to be yours — built from your team’s actual delegation failures and actual verification near-misses, not a generic curriculum bolted onto a seat license. Anthropic building the scaffolding for that is useful. Skipping the internal work because the scaffolding now exists is the mistake most orgs are about to make.