AI Fluency: Anthropic's 4D Framework, explained

AI Fluency: Framework & Foundations is Anthropic's free course on working with AI well. It is not a Claude tutorial. It teaches a way of thinking that outlives whichever model you happen to be using.

The definition is one sentence. AI Fluency means "interacting with AI systems in ways that are effective, efficient, ethical and safe". Four adjectives, and all four are load-bearing.

• Effective and efficient are not the same claim. Effective is getting the right result. Efficient is getting it without burning more of your time than doing it yourself would have. Plenty of AI usage clears the first bar and fails the second.
• Ethical and safe are in the definition, not bolted on. They sit alongside the performance goals rather than in a compliance appendix, which is a deliberate choice by the authors.
• The unit is a competency, not a skill. The course is explicit that competencies are "interconnected collections of skills, knowledge, insights, values". You cannot pick up a competency from a cheat sheet.

• Two academics plus Anthropic. Prof. Rick Dakan of Ringling College of Art and Design and Prof. Joseph Feller of University College Cork, with technical and practical content from Maggie Vo and Drew Bent at Anthropic.
• The base material predates the course. It came from the authors' own framework summary document, working papers and research notes, plus slide decks and lecture transcripts from university courses, guest lectures and research talks. This is taught material that was already being taught.
• It is openly licensed. Released under CC BY-NC-SA 4.0 by Rick Dakan, Joseph Feller and Anthropic. You may share and adapt it non-commercially with attribution, under the same licence.
• The course discloses its own AI use. A published statement records that the authors "engaged in extensive collaboration with Claude 3.7", that Claude "assisted one or more of the human authors with structural development, resource and exercise design, and content drafting, critiquing, editing and rewriting", and that the humans "made all final decisions about both content and approach".

The framework is "four interconnected competencies necessary to ensure our interactions with AI are effective, efficient, ethical and safe". Interconnected is the operative word: they are a cycle, not a checklist.

• Delegation without Discernment ships slop. You picked a good task and never checked the answer, so the failure arrives later and with your name on it.
• Description without Delegation is wasted craft. A beautifully engineered prompt for work that should never have gone to AI is still wasted work.
• Discernment without Description is a dead end. Spotting that the output is wrong helps only if you can then say what would have been right.
• Diligence without the other three is theatre. Taking responsibility for a process you did not steer is a signature on someone else's homework.
• Weakest link, not average. Because they compound, your fluency is set by the D you are worst at. That is where the study time should go.

The course names three modes, and the four competencies map across all three. The same competency asks a different question in each mode, which is why "how do I prompt better" is an incomplete question.

• Automation is cheap to supervise and cheap to abandon. One task, one output, one check. If it is wrong you see it immediately, and the blast radius is that one task.
• Augmentation is where most real work happens. Turn by turn, and the cost is attention: you have to stay in the conversation rather than skim it.
• Agency front-loads everything. You are not describing a task, you are describing a standing policy for tasks you have not seen yet. Every ambiguity you leave in gets applied repeatedly while you are not watching.
• Discernment gets harder as you move down. In automation you judge one output. In agency you have to judge behaviour you were not present for, from artefacts left behind.

1. Set the goal first, in your own words. Not the task, the outcome. If you cannot state what done looks like without mentioning a tool, the goal is not clear enough to delegate.
2. Decide whether. Some work should not go to AI at all: because you would spend longer describing it than doing it, because the judgement involved is the point, or because you are the accountable expert and delegating it removes the expertise from the loop.
3. Decide when. The same task delegated at the wrong moment wastes the effort. Handing over a design before you know the constraints produces a confident answer to the wrong question.
4. Decide how. Which of the three modes fits. A one-off exploration is augmentation. A repeated mechanical transform is automation. A standing job is agency, and only once you have done it by hand enough to know what good looks like.

What to keep, and why

• Keep the work where the thinking is the deliverable. If the point of the task is that you understood something, outsourcing it delivers the artefact and destroys the purpose.
• Keep what you cannot evaluate. Delegating work you have no way to check is not delegation, it is hoping. If you could not tell a good answer from a plausible one, that is a Discernment gap, and it makes the task undelegatable for now.
• Keep what you are accountable for at the point of judgement. You can delegate drafting the risk assessment. You cannot delegate deciding the risk is acceptable.
• Delegate the volume, keep the verdict. The reliable split. AI produces breadth, you supply the decision.
• Revisit the decision as your skill grows. Something undelegatable today because you cannot evaluate it becomes delegatable once you can. Delegation is a judgement that expires.

• Product Description. What you want back. Format, length, structure, audience, constraints. Most people write only this part and wonder why the shape is right and the substance is not.
• Process Description. How you want it approached. Reason step by step, ask before assuming, work from this source, show alternatives before committing. This is the part that changes answer quality most and gets written least.
• Performance Description. How you want it to behave while working. Tone, level of pushback, how much to explain, when to stop and check in.

The value of the three-way split is diagnostic. When an answer disappoints, you can locate which description was missing instead of rewriting the prompt at random.

Discernment is Description's counterpart. The course frames it directly: where Description shapes what goes in, Discernment shapes how you respond to what comes out.

• Judge the output and the behaviour. The definition names both. Not just "is this answer right" but "is this a sensible way of working": did it invent a source, skip a constraint, agree too readily.
• The loop terminates on your judgement, not on the AI's confidence. Fluent output is not evidence of a good answer, and the model's certainty carries no information about correctness.
• Iteration is the skill. Not the perfect opening prompt.

Diligence is "taking responsibility for what we do with AI and how we do it". The course approaches it through three lenses.

• Creation. How the work was made. Which tool, on what material, with what checks. Whether you had the right to use the inputs you fed it, and whether the process would survive being described out loud.
• Transparency. Whether the people who need to know, know. Not a blanket confession on everything, a judgement about who is entitled to the information and what they would want to be told.
• Deployment. What happens once the work is out. Who is affected, what breaks if it is wrong, and whether anyone downstream can tell it was AI-assisted when that matters to them.

Responsibility does not transfer. This is the whole competency in one line. There is no configuration, no disclaimer and no mode of use that moves accountability from you to the system.

What it looks like when it is real:

• Disclosure that is specific. "AI-assisted" tells a reader nothing. The course's own statement names the model, lists what it did, names what the humans did, and says who decided. That is the standard to copy.
• Checks proportional to consequence. A brainstorm needs a glance. Anything that will be acted on by someone who trusts you needs a real review, and the review has to be capable of catching the failure you are worried about.
• Honesty about what you did not verify. Stating the limits of your own checking is more useful than implying you checked everything.

The course is free, self-paced, and takes a few hours. There is one thing to get right before you start, and it is where you take it.

• Two official homes, and they do not agree. Anthropic Academy states that after finishing "you will have the opportunity to take a final assessment and receive a certificate of completion", and lists "Certificate of completion" as a lesson. The Coursera listing of the same course states the opposite in its FAQ: "No certificates, credentials, or reports are awarded in connection with this course."
• If you want the certificate, use Anthropic Academy. That is the practical consequence.
• No Claude account or paid plan is needed. The academy is hosted on Skilljar and an Anthropic account is not required for the course itself. Registration reads "Register | FREE".
• Budget about three hours. Coursera lists ten modules, roughly three hours, and a fifteen-minute course quiz. Anthropic does not publish its own per-module timings.

The syllabus, in order

1. Introduction to AI Fluency. Framing, and why the course exists.
2. The AI Fluency Framework. Why fluency is needed, then the 4D Framework itself.
3. Deep Dive 1: What is Generative AI? Fundamentals, then capabilities and limitations.
4. Delegation. A closer look, then project planning and delegation.
5. Description. A closer look, followed by a deep dive on effective prompting techniques.
6. Discernment, then the Description-Discernment loop. Taught separately, then joined.
7. Diligence. A closer look.
8. Conclusion and certificate. Conclusion, certificate of completion, and additional activities.

The framework is deliberately tool-agnostic, which makes it abstract on first read. Here it is applied end to end to one ordinary task: turning a ticket into tests you would actually run.

1. Delegate: decide the split before opening a chat. The goal is a test suite you trust for this ticket. Generating candidate cases is breadth, so it delegates well. Deciding which cases matter and what risk is acceptable is the verdict, so it stays with you. If you cannot yet tell a good test case from a plausible one for this feature, that is the signal to read the ticket properly first.
2. Describe: write all three descriptions. Product: the format, the framework, how many cases, what to exclude. Process: work only from the acceptance criteria, ask before inventing behaviour, list edge cases separately from the happy path. Performance: flag ambiguities in the ticket rather than resolving them silently.
3. Discern: judge the behaviour as well as the output. Read for cases derived from something not in the ticket, acceptance criteria quietly dropped, and edge cases that are variations rather than genuinely different risks. A run that invented a requirement is a behaviour problem, not an output problem, and it means the process description was thin.
4. Refine, and expect to. Feed back the specific gap rather than starting over. Missing negative cases is a process description you did not write.
5. Diligence: decide what you own and what you disclose. You are accountable for the suite whether or not you wrote each line. If the cases go to someone who will trust them without reading the ticket, say how they were produced and what you checked.

Picking the mode for QA work

The course is free and takes an afternoon. The framework is the part worth keeping.