Anthropic Academy is the official learning platform from Anthropic, the AI lab behind Claude — free, self-paced, and built for non-technical professionals and developers alike. Its completion certificates are structured, verifiable evidence of hands-on AI skill, taught by the teams that write Claude's own documentation.
Anthropic Academy offers a growing catalog of free, self-paced courses — hosted at anthropic.skilljar.com — covering everything from everyday AI fluency to building production applications on the Claude API, mastering Claude Code, and developing Model Context Protocol (MCP) servers. Every course ends with a completion certificate you can add to your LinkedIn profile and résumé.
This is a fundamentally different kind of credential from the proctored, paid certification exams offered by AWS, Microsoft, or Google Cloud. There is no exam center, no proctor, no fee, and no scheduled sitting. You enroll, work through video lessons and hands-on exercises at your own pace, pass short in-course assessments, and receive a certificate directly from a frontier AI lab. That last part is what makes these credentials worth your time: they come from the company that builds the models, and the material is written by the same teams that write Claude's official documentation. When Anthropic teaches prompt caching or tool use, you are learning it from the source.
Because there is no exam to cram for, this guide is not exam prep. It is a complete walkthrough of the learning path: which courses exist, what each one actually teaches, what order to take them in, how long each takes, how the certificates work, and what to build afterward so the credential translates into demonstrable skill.
Who is this for? Two audiences, and the catalog is deliberately split between them:
Why it matters in 2026: employers increasingly screen for practical AI skills, and "I use ChatGPT sometimes" no longer differentiates anyone. A set of completion certificates from Anthropic — free to earn, verifiable, and tied to hands-on coursework — is one of the fastest ways to put structured evidence of AI capability on your profile. For developers, the Academy courses are also the most direct on-ramp to the Claude ecosystem that powers a large share of today's agentic tooling.
| Fact | Detail |
|---|---|
| Provider | Anthropic (Anthropic Academy) |
| Platform | anthropic.skilljar.com (linked from anthropic.com/learn) |
| Cost | Free — all courses, all certificates |
| Format | Self-paced online courses: video lessons, readings, hands-on exercises, short quizzes/assessments |
| Credential | Certificate of completion per course (no proctored exam) |
| Time per course | Roughly 1–6 hours depending on the course; the full developer path is ~15–25 hours |
| Prerequisites | None for AI Fluency courses; Python/JavaScript and command-line basics for developer courses |
| Expiry | Certificates do not expire (though course content is updated as Claude evolves) |
| Catalog size | ~20 courses as of mid-2026, across AI Fluency, developer, and platform tracks |
This guide is organized as a recommended learning path in five parts:
If you are non-technical, read Parts 1, 2, 4, and 5. If you are a developer, read Parts 1, 3, 4, and 5 — but consider skimming Part 2 anyway, because the 4D framework taught in AI Fluency is genuinely useful vocabulary for anyone who works with models daily.
Course names, groupings, and content reflect the Anthropic Academy catalog as of July 2026. Anthropic updates courses as Claude and its tooling evolve — new courses (like Introduction to Claude Cowork) appear regularly — so treat the catalog page itself as the source of truth for what is currently offered.
Getting started takes about five minutes:
Your Skilljar dashboard tracks enrolled courses, progress within each course, and completed certificates. Courses remember your position, so you can do a lesson on your lunch break and pick up exactly where you left off.
Register with the same email you use for your Claude account (claude.ai) and, if you are a developer, your Claude Console account (platform.claude.com). Several developer courses have you work directly against the API or in Claude Code, and keeping one identity across all three makes the hands-on exercises smoother.
As of mid-2026 the catalog contains roughly twenty courses. They cluster naturally into four groups:
Foundations and everyday use. Claude 101 (using Claude for everyday work tasks), AI Capabilities and Limitations (an introductory course on how AI actually works), and Introduction to Claude Cowork (Anthropic's agentic workspace — the task loop, plugins, skills, and file workflows).
The AI Fluency series. The flagship AI Fluency: Framework & Foundations, plus role-specific variants: AI Fluency for Students, AI Fluency for Educators, Teaching AI Fluency (for instructors who will teach the material to others), AI Fluency for Nonprofits, AI Fluency for Small Businesses, and AI Fluency for Builders (entrepreneurs and product developers).
The developer core. Claude Platform 101 (beginner-to-intermediate on the Claude Developer Platform), Building with the Claude API (the comprehensive deep course), Claude Code 101, Claude Code in Action, Introduction to Agent Skills, Introduction to Subagents, Introduction to Model Context Protocol, and Model Context Protocol: Advanced Topics.
Cloud platform courses. Claude with Amazon Bedrock and Claude with Google Cloud's Vertex AI — for teams that consume Claude through a hyperscaler rather than directly from Anthropic.
The single most important decision is which track to start with, and it comes down to one question: will you write code against Claude, or work alongside it?
| You are… | Start with | Then | Total time |
|---|---|---|---|
| A knowledge worker, manager, or analyst | Claude 101 | AI Fluency: Framework & Foundations → Introduction to Claude Cowork | ~4–7 hours |
| A student or educator | AI Fluency for Students / for Educators | Framework & Foundations for depth | ~3–6 hours |
| A founder or product person (non-coding) | AI Fluency for Builders | Framework & Foundations → Claude 101 | ~4–7 hours |
| A developer new to Claude | Claude Platform 101 | Building with the Claude API → Claude Code in Action → both MCP courses | ~15–25 hours |
| A developer already using Claude Code daily | Claude Code in Action | Agent Skills → Subagents → MCP courses | ~8–14 hours |
| An enterprise/cloud engineer | Building with the Claude API | Claude with Amazon Bedrock or Vertex AI | ~8–12 hours |
You are not locked into a track. Everything is free, so the real constraint is your time. Many developers take Framework & Foundations as a warm-up; many non-technical learners eventually poke at Claude Code. The recommendations above are simply the fastest route to a coherent set of certificates for your role.
Anthropic Academy has two spines — AI Fluency for people who work with AI, and the developer path for people who build on AI. Pick your spine first, finish it completely, then branch into the specialized courses. A finished track reads far better on a profile than five half-started courses.
The AI Fluency series is Anthropic's answer to a real problem: most people use AI badly, not because the tools are hard, but because nobody taught them a mental model for collaboration with a system that is neither a search engine nor a colleague. The series was developed in partnership with academic experts from University College Cork and Ringling College, which shows in its structure — it reads like a well-designed university short course, not marketing content.
This is the flagship, and if you take only one non-technical course from Anthropic, take this one. It requires no prior AI experience, works whether you use Claude, another assistant, or several, and typically takes three to five hours to complete.
The course is built around the 4D Framework — four competencies that together define fluent AI collaboration:
Delegation — deciding what to hand to AI in the first place. This is the skill almost nobody teaches: auditing your own work, distinguishing tasks where AI excels (drafting, transformation, summarization, brainstorming breadth) from tasks where it struggles or where human judgment is non-negotiable, and planning projects so that AI-suitable pieces are cleanly separable. The course includes dedicated lessons on project planning through the delegation lens.
Description — communicating what you want. This is prompting, but taught properly: providing context and constraints, specifying format and audience, supplying examples, and iterating rather than expecting a perfect one-shot answer. The "effective prompting techniques" lessons here are the practical core of the course, and they map directly onto how Claude's own documentation teaches prompt design.
Discernment — critically evaluating what you get back. You learn to check outputs for accuracy, completeness, tone, and hidden assumptions, and — crucially — the course teaches the Description–Discernment loop: the iterative cycle of prompting, evaluating, and re-prompting that separates fluent users from people who accept the first draft. This is where hallucination awareness lives, framed as a workflow habit rather than a scare story.
Diligence — using AI ethically, safely, and accountably. Transparency about AI use, responsibility for outputs you ship under your name, data privacy when prompting, and understanding where accountability sits when AI contributes to your work.
The course closes with a final assessment; passing it earns your certificate of completion.
The 4D Framework — Delegation, Description, Discernment, Diligence — is the intellectual core of the entire AI Fluency series. Every role-specific variant applies these same four competencies to a different context, so master them once in Framework & Foundations and the other courses become fast, targeted refreshers.
Do the exercises with a real task from your actual job, not the hypotheticals. Take a report you genuinely need to write or a dataset you genuinely need to summarize, and run it through the Description–Discernment loop as you learn it. The certificate is nice; the changed daily workflow is the point.
A short introductory course on how modern AI systems actually work — what a large language model is doing when it generates text, why it can be brilliant and wrong in the same paragraph, and where the hard edges of the technology sit. Take this if you find yourself unable to explain why the Discernment step matters, or if you brief others on AI and need to answer "but how does it really work?" credibly. It pairs naturally with Framework & Foundations, in either order. Budget one to two hours.
Claude 101 is the practical companion to the fluency theory: how to use Claude itself for everyday work — core features, Projects, file handling, and where to go for more advanced learning. If Framework & Foundations teaches you how to think about AI collaboration, Claude 101 teaches you where the buttons are. One to two hours.
Introduction to Claude Cowork covers Anthropic's agentic workspace: the task loop (how Cowork plans, executes, and reports on multi-step work), plugins, skills, and file workflows. This course matters because it represents the shift from "chat with an assistant" to "delegate a task to an agent" — the Delegation competency made concrete. If your organization has adopted Cowork or Claude for Work, this is the fastest onboarding available. One to two hours.
Six courses adapt AI fluency to specific audiences. Each stands alone — you do not need Framework & Foundations first, though it deepens all of them.
| Course | Audience | Distinct emphasis |
|---|---|---|
| AI Fluency for Students | University and school students | Academic integrity, learning with AI rather than outsourcing learning to it, study workflows |
| AI Fluency for Educators | Faculty and educational leaders | Curriculum integration, assignment design in an AI world, institutional policy |
| Teaching AI Fluency | Instructors and trainers | How to teach the 4D framework to others — classroom-ready materials and pedagogy |
| AI Fluency for Nonprofits | Nonprofit professionals | Mission-driven use cases, grant writing, communications, resource-constrained adoption |
| AI Fluency for Small Businesses | Small business owners and staff | Marketing, operations, customer communication with minimal budget and no IT department |
| AI Fluency for Builders | Entrepreneurs and product developers | Prototyping, product thinking with AI, moving from idea to build |
Each variant runs roughly two to four hours and grants its own certificate.
These variants are certificates in their own right. An educator who completes Framework & Foundations, AI Fluency for Educators, and Teaching AI Fluency has three Anthropic credentials that together tell a coherent professional story — qualified to use AI, to integrate it into teaching, and to train colleagues.
Teaching AI Fluency deserves special mention for trainers and L&D professionals: it is explicitly designed to prepare you to deliver AI fluency instruction to others, which makes it one of the few free "train-the-trainer" AI credentials available from a frontier lab.
The developer track is where Anthropic Academy earns its keep for engineers. The courses are hands-on — you write real code against the real API — and they mirror the official documentation closely enough that finishing them leaves you genuinely productive, not just certified.
The recommended sequence: Claude Platform 101 → Building with the Claude API → Claude Code 101 → Claude Code in Action → Agent Skills → Subagents → Introduction to MCP → MCP Advanced Topics, with the Bedrock/Vertex courses slotted in if your employer consumes Claude through a cloud provider.
Claude Platform 101 takes you from beginner to intermediate on the Claude Developer Platform: getting an API key from the Console, understanding the model family (the Opus, Sonnet, and Haiku tiers and when each makes sense on the cost/capability curve), the Workbench for interactive prompt iteration, and the basic anatomy of an API call. If you have never touched the Claude API, start here — it removes every setup obstacle before the deeper course. Two to three hours.
If you skipped Part 2: Claude 101 is also worth an hour even for developers, because knowing the end-user surface (claude.ai, Projects, artifacts) informs how you design what you build.
This is the most comprehensive course in the catalog — a full-spectrum treatment of working with Anthropic models through the Claude API. Budget six to ten hours, more if you do every exercise. Expect it to cover, in roughly this arc:
Models and the Messages API. The request/response lifecycle: the messages endpoint, system prompts versus user turns, multi-turn conversation state (the API is stateless — you resend history), max_tokens, temperature, and stop sequences. Model selection is treated as an engineering decision: Haiku for high-volume/low-latency, Sonnet for the everyday workhorse, Opus for frontier reasoning.
Prompt engineering for the API. The programmatic side of Description: XML-tagged structure in prompts, few-shot examples, prefilling the assistant turn to control output format, and chaining prompts across calls.
Tool use (function calling). Defining tools with JSON Schema, the tool-use loop (model requests a tool → your code executes it → you return the result → model continues), parallel tool calls, and forcing tool choice. This section is the foundation for everything agentic, and the course treats it that way.
Structured outputs, vision, and files. Getting reliable JSON out of the model, sending images, and working with documents.
Prompt caching. One of the highest-ROI topics in the course: marking stable prefixes of your prompt (long system prompts, reference documents, tool definitions) as cacheable so repeat calls are dramatically cheaper and faster. The course covers cache breakpoints, minimum cacheable lengths, and cache lifetimes — details that directly change your production bill.
Streaming, embeddings-adjacent patterns, and RAG. Server-sent event streaming for responsive UIs, plus retrieval-augmented generation architecture: chunking, retrieval, and grounding Claude's answers in your own data.
Agents and evaluation. Composing tool use into agentic loops, and — a section too many self-taught developers skip — evaluating prompts systematically instead of eyeballing outputs.
If you earn one developer certificate from Anthropic Academy, make it Building with the Claude API. It is the closest thing to a canonical "Claude developer" credential, and its tool-use and prompt-caching sections pay for the time investment in the first week of real work.
The API costs money even though the course is free. Load $5–10 of credit into your Console account before starting and do the exercises against Haiku or Sonnet rather than Opus — the entire course's exercises will cost you a dollar or two, and the muscle memory of watching your own token usage is itself a lesson in cost-aware engineering.
Claude Code is Anthropic's agentic coding tool — it lives in your terminal (and IDE, and GitHub), reads your codebase, edits files, runs commands, and executes multi-step engineering tasks. Two courses cover it.
Claude Code 101 is the daily-workflow course: installing and authenticating, the core interaction loop, giving effective instructions, reviewing diffs, and the habits that make an agentic tool a productivity multiplier rather than a chaos generator. One to two hours, and appropriate even if you are only Claude Code-curious.
Claude Code in Action is the serious course, structured in four sections across seventeen lessons:
Prerequisites are honest but light: command-line familiarity and basic Git. The stated audience is software developers integrating AI assistance into their workflows and teams implementing AI-powered GitHub integration. Budget three to five hours.
Two short, focused courses extend the Claude Code material:
Introduction to Agent Skills teaches Skills — reusable, packaged capabilities (instructions plus optional scripts and resources) that Claude loads on demand. You learn to author a skill, structure its instructions so the agent triggers it at the right moments, and share it across projects and teams. Skills are how you turn "the prompt that works" into an installable asset. One to two hours.
Introduction to Subagents covers delegation within the agent: spinning up specialized sub-agents with their own context windows and tool permissions to handle scoped pieces of a larger task — a research subagent, a test-writing subagent, a code-review subagent. You learn when decomposition helps (parallel independent work, context isolation) and when it just adds overhead. One to two hours.
Take both immediately after Claude Code in Action while the mental model is fresh; together they represent the current frontier of practical agent orchestration, and they are short.
Model Context Protocol is the open standard — created by Anthropic, now adopted across the industry — for connecting AI models to external tools, data, and systems. If tool use in the API course was one app defining its own tools, MCP is the ecosystem version: build a server once and any MCP-compatible client (Claude Code, Claude Desktop, Cowork, and a long list of third-party agents) can use it.
Introduction to Model Context Protocol is a Python-based, hands-on course in four sections: an MCP overview; building your first server (project setup, defining tools, testing with the MCP Inspector); connecting from clients and implementing the other two core primitives — resources (data the server exposes) and prompts (templated interactions it offers); then a final assessment. Prerequisites: working Python, basic JSON and HTTP. Two to four hours, and by the end you have a functioning MCP server of your own.
Model Context Protocol: Advanced Topics moves to production concerns: transport choices and remote servers, authentication and security, sampling (servers asking the client's model to run completions), and the patterns that separate a demo server from something a team can actually deploy. Take it only after the introduction, and budget three to five hours.
MCP skills compound. The protocol is client-agnostic, so one well-built server — say, an MCP wrapper around your company's internal API — instantly works in Claude Code, Claude Desktop, Cowork, and every other MCP client your team adopts later. The two MCP certificates signal exactly this leverage to employers.
The MCP intro course teaches in Python, but the protocol itself is language-agnostic and official SDKs exist for TypeScript, Python, and other languages. The concepts — tools, resources, prompts, the inspector-driven development loop — transfer directly.
Many enterprises consume Claude through their existing cloud contracts rather than directly from Anthropic. These two courses cover exactly that: provisioning and invoking Claude models through Amazon Bedrock or Google Cloud Vertex AI — authentication with IAM/service accounts instead of Anthropic API keys, request shape differences, regional availability, and how platform features (guardrails, provisioned throughput, VPC endpoints) wrap around the model.
Take the relevant course if — and realistically only if — your organization runs on that cloud. The Claude fundamentals inside are the same as Building with the Claude API; the value is in the platform-specific plumbing. Two to three hours each. For AWS-based readers, Claude with Amazon Bedrock is also the natural bridge toward AWS's own AI certifications, which we return to in Part 5.
Sequence matters more than speed on this track. Building with the Claude API before Claude Code in Action means you understand what the agent is doing under the hood (a tool-use loop) rather than treating it as magic. Introduction to MCP before Advanced Topics is non-negotiable. Everything else can flex around your job's demands.
Every Anthropic Academy course grants a certificate of completion. The mechanics are simple and consistent:
There is no expiry, no renewal fee, and no continuing-education requirement. The honest caveat: because these are unproctored completion certificates, they carry less standalone weight than a proctored credential like an AWS certification. Their value comes from three things — the issuer (a frontier lab), the stack (a full track of certificates telling a coherent story), and most importantly what you can demonstrate alongside them, which is what Part 5 is for.
These are certificates of completion, not proctored certifications. Present them accurately — "Anthropic Academy: Building with the Claude API (certificate of completion)" — and pair them with visible work. Overstating a completion certificate as a "certification exam" undermines the credibility it genuinely has.
Do this properly and each certificate becomes a searchable, clickable credential:
Beyond the certifications section: add relevant skills to your profile ("Claude API", "Model Context Protocol", "Prompt Engineering", "AI Fluency", "Claude Code") so recruiter searches find you, and consider a short post when you finish a track — a two-paragraph writeup of what you built during the courses outperforms a certificate image alone.
Batch your LinkedIn updates by track, not by course. One update announcing "completed Anthropic's developer track — five courses covering the Claude API, Claude Code, and MCP, plus the demo project below" lands far harder than five separate certificate posts, and it frames you as someone who finishes learning paths.
A completion certificate opens the conversation; a working project ends it. The single best thing you can do after each course is build something small, public, and directly traceable to the skills the course taught. Here is a project ladder matched to the track you completed.
| After completing… | Build this | It proves |
|---|---|---|
| AI Fluency track | A documented AI workflow for your real job: a prompt library + before/after examples of one recurring task (report, analysis, lesson plan) run through the 4D framework | Delegation judgment and the Description–Discernment loop, in your actual domain |
| Building with the Claude API | A tool-using assistant: e.g., a support bot that reads your product docs (RAG) and calls a ticket-creation tool; instrument it with prompt caching and log the cost savings | Messages API, tool use, RAG, caching — the whole course in one artifact |
| Claude Code in Action | A public repo with a tuned CLAUDE.md, two custom slash commands, and a hook that enforces your lint/test policy; a README section on how the agent is configured | Real agentic-workflow engineering, not just tool tourism |
| Agent Skills + Subagents | A packaged skill your team actually installs (e.g., "write release notes in our house style"), plus a subagent setup for a real multi-part task | Ability to productize prompts into reusable team assets |
| MCP courses | An MCP server for something you own — your notes app, home lab, or company's internal API — with tools, one resource, and one prompt; test it in Claude Code and Claude Desktop | End-to-end MCP competence across two clients |
| Bedrock / Vertex AI course | The API-course assistant redeployed through Bedrock or Vertex with IAM auth and platform guardrails | Enterprise-grade deployment of the same skills |
Three principles make these projects count:
Make them public. A GitHub repo with a clear README, or a short demo video, or a blog post walking through the architecture. Private learning is real, but invisible.
Make them specific to you. An MCP server for a generic to-do API is a tutorial; an MCP server for your company's internal tooling (suitably sanitized) is evidence of judgment.
Write down the numbers. "Added prompt caching, cut per-conversation cost 60%" is the kind of line that survives contact with a hiring manager.
Anthropic Academy certificates and proctored certifications are complements, not competitors — and the bridge between them is shorter than it looks. The first place to look is now Anthropic itself:
The strategic combination for 2026 job markets: one free Anthropic track (proof of hands-on frontier-lab skills) plus one proctored certification (proof that survives résumé screening) — starting with Anthropic's own exam ladder, then a cloud credential if your employer runs on one. Each makes the other stronger — the Academy courses give you the practical fluency that makes the exams easier, and the proctored cert supplies the formal rigor completion certificates lack.
Treat Anthropic Academy as the skills layer and a proctored certification as the validation layer. Free Anthropic certificates + a portfolio project + an Anthropic proctored exam (CCAO-F or CCDV-F), AWS AI Practitioner, or Azure AI-901 is a complete, credible AI credential stack that costs you one exam fee and a few weekends.
The catalog keeps growing — Cowork, agent skills, and subagents courses all appeared within the last year. Check anthropic.skilljar.com every quarter, because being early to a new course on a new capability (as MCP learners were in 2025) is a genuine career advantage. Everything is free; the only investment is attention.