AI Fluency: A Crash Course

4 competencies. 3 ways to work with AI. One practical habit: decide, describe, check, and take responsibility.

Imagine a talented new colleague joins your team.

On her first morning, you say:

"Prepare a course outline on AI agents."

A few hours later, she gives you a polished outline. But there is a problem. It is written for PhD researchers. It assumes you have a full semester. It has almost no hands-on practice.

Was she incapable? No.

The real problem is that you did not tell her enough. You did not explain the audience, the time available, the teaching style, or what students should be able to do at the end.

📚 Teaching Aid

Open Full Slideshow

View Full Presentation: Agentic Coding Crash Course

---

Working with AI is similar, with one difference that matters.

A new colleague learns. Tell her once that your students are beginners and she still knows it next month. AI does not work that way. It carries nothing from one conversation into the next, so every chat opens with a colleague who has never met you. Whatever you would tell a person once, you either say again each time or put somewhere the AI reads automatically. That is not a flaw to complain about. It is a working condition to plan around, and planning around it is one of the four skills below.

A powerful AI can still give you the wrong result when the collaboration is poor. Knowing a few clever prompts is not enough. You need to know what to give AI, how to guide it, how to judge its work, and when not to trust or use it.

That is what AI fluency means.

This course teaches the AI Fluency Framework, created by Professor Rick Dakan and Professor Joseph Feller and taught through courses produced with Anthropic. The framework has four human competencies, called the 4Ds:

1. Delegation: decide what AI should do.
2. Description: explain what you need.
3. Discernment: judge what AI gives you.
4. Diligence: use AI responsibly and own the outcome.

You will use these same four skills whether you are chatting with an assistant, coding with an AI agent, or building a Digital FTE that works for other people.

Reading time: about 30 minutes, plus 15–20 minutes for the practice prompts and self-check.

The whole course in one minute

If you remember only four questions, remember these:

Competency	Plain-English question
Delegation	What should AI do, and what should stay with me?
Description	What does AI need to know to do the work well?
Discernment	Is the result actually good and trustworthy?
Diligence	Is this a responsible way to use AI, and am I ready to own the result?

You will spend the rest of the course learning how to answer these four questions well.

Where this sits in Foundations

Read What AI Actually Is before this course. That course explains the machine. This course explains how you should work with the machine. AI Prompting in 2026, which comes next, teaches the practical techniques.

A useful sequence is:

The machine → the collaboration → the techniques

Topic	What AI Actually Is	This course	AI Prompting in 2026
How AI works	In depth	Quick reminder	Assumed
How to communicate	Why context matters	Description	Practical prompting techniques
How to judge answers	Why plausible can be wrong	Discernment	Model-checking habits
What to give AI	The jagged frontier	Delegation	Choosing models and tools
Responsible use	Mostly out of scope	Diligence	Safe tool use and permissions

The techniques will change as models improve. The four competencies are designed to last.

See it in three minutes

Before any of the theory, watch the thing this course is about actually happen.

Open any AI assistant. Paste this and read what comes back:

Write a welcome email for new members.

Read it properly. It will be competent, grammatical, and completely generic, because you gave it nothing to work with. Now open a fresh chat and paste this:

Write a welcome email for new members of a small women's cycling club
in Karachi. Most are nervous beginners who have never ridden in traffic.
Warm and a bit funny, under 150 words, no exclamation marks. End by
telling them the Saturday 6am ride is slow on purpose and nobody gets
dropped.

Same model. Same task. Same three seconds of work for the machine.

The second email is better because the second request carried the information the first one left out: who these people are, what they are afraid of, how it should sound, how long, and what the point is. Nothing clever happened. Something was simply said that had not been said before.

Hold on to two things you just noticed:

1. The gap between the two results came from you, not from the model.
2. You could only tell the second email was better because you understood cycling clubs, or nervous beginners, or Karachi, well enough to judge it.

The first is Description. The second is Discernment. Two of the four skills, already in your hands three minutes in. The rest of this course names all four, shows you where each one fails, and shows what each becomes when you stop working alone in a chat window and start building AI that works for other people.

What you should understand by the end

By the end of this course, you should be able to explain:

• what AI fluency means beyond "being good at prompts";
• the difference between automation, augmentation, and agency;
• how to decide which work belongs to you and which belongs to AI;
• the three kinds of Description: product, process, and performance;
• how to evaluate AI output instead of accepting it because it sounds confident;
• the three kinds of Diligence: creation, transparency, and deployment;
• how all four competencies work together on a real project; and
• how these personal skills scale into Agent Factory engineering practices.

Part 1: Start with the big picture

1. AI access is not AI fluency

Having access to a powerful AI does not mean you know how to use it well.

Almost everyone reading this has the same models available. Two people open the same assistant, on the same plan, on the same morning, and one of them gets work worth shipping while the other gets a polished thing they quietly throw away. The tool did not differ. What they did with it did.

AI fluency means working with AI in ways that are:

• Effective: you reach the goal.
• Efficient: you do not burn time, effort, or tokens you did not need to spend.
• Ethical: you use AI fairly and honestly.
• Safe: you protect people, privacy, security, and important information.

Notice what is not in that definition.

You do not need to know how to train a large language model. You do not need to understand every detail of transformers. You do not need a collection of "magic prompts."

Those things may be useful, but they are not the foundation.

The foundation is learning how to make good human decisions around AI.

That is why the framework focuses on the 4Ds:

Delegation → Description → Discernment → Diligence

A simple way to remember them is:

Decide → Explain → Check → Own

The official competency names matter, and we will use them throughout the book. The plain-English version is there to help you remember what each one does.

For Agent Factory readers, this comes before everything else. In Mode 1, you use general agents to solve problems. In Mode 2, you build Digital FTEs for other people. Both require AI fluency.

If you cannot work well with one AI assistant, you are not ready to design an AI system that may act for hundreds or thousands of users.

Three facts to carry from the previous course

What AI Actually Is taught many ideas about language models. Keep these three in your head:

1. Plausible is not the same as correct. AI can produce a confident answer that is wrong. This is often called a hallucination.
2. Outputs can vary. The same request can produce different answers at different times.
3. AI only works with the information available to it. That may include its trained knowledge, the current conversation, documents, memory, search, and other connected tools. If important information is missing, the AI may guess.

So treat AI output like work from a capable colleague: useful, often impressive, but still something you must review.

2. Three ways to work with AI: automation, augmentation, and agency

Before learning the 4Ds, you need one more idea.

Humans can work with AI in three broad modes:

1. Automation: AI performs a task you specify.
2. Augmentation: you and AI work on the task together.
3. Agency: AI works toward a goal on your behalf.

The difference is mainly about how much freedom the AI has to decide what to do next.

Automation: "Do this task"

With automation, you tell AI exactly what task to perform.

Examples:

• "Summarize this report in five bullets."
• "Translate this email into Urdu."
• "Extract the invoice number, date, and total from this PDF."

You are close to a script writer. You define the task. AI executes it.

Automation is useful when the work is clear and repeatable.

Augmentation: "Help me think"

With augmentation, you and AI work together.

Examples:

• brainstorming a business idea;
• reviewing a software architecture;
• improving a lesson plan;
• comparing two strategies; or
• exploring a question where you do not yet know the answer.

Here, AI is not simply executing instructions. It is acting more like a thinking partner.

You may go back and forth for many turns. You ask. It responds. You challenge. It revises. Together, you improve the result.

Agency: "Pursue this goal for me"

With agency, you give AI a goal and boundaries, then allow it to decide many of the steps.

For example, instead of saying:

"Read these five emails and summarize them."

You might say:

"Keep my inbox manageable. Reply to routine messages, flag important ones, and ask me before doing anything you are unsure about."

Now the AI must make decisions. Which message is routine? Which one is important? When should it ask you?

You have moved from script writer to director.

There is a second half of agency that beginners miss, and it is the half this book is built on. The framework's own definition is that a human configures AI to independently perform future tasks, including for others, on their behalf. Read that again slowly. Two words carry the weight.

Future means you are not in the room. You set the AI up on Monday and it handles Thursday's work while you are asleep.

For others means the person the AI serves may not be you at all. You configure it; your customer, your student, or your colleague is the one who talks to it.

Automation and augmentation both keep you in the chair. Agency is the mode where you get out of the chair, and everything that makes Mode 2 hard follows from that one fact: you cannot supervise every decision, so the judgment has to be built in beforehand.

The difference between automation and agency is especially important:

	Automation	Agency
You provide	The task or steps	The goal and boundaries
AI decides	Very little	Many next steps
Your role	Script writer	Director
Common failure	A step is done badly	The goal or boundary is misunderstood

None of these modes is automatically better.

A good AI user chooses the mode that fits the work.

A single project may use all three. You might automate data extraction, use augmentation to think through exceptions, and then give an agent limited authority to handle routine cases.

In Agent Factory terms, Mode 1 uses a lot of automation and augmentation. Mode 2 makes agency systematic. A Digital FTE is not merely "AI doing things." It is AI acting within a job definition, a System of Record, permissions, rules, and governance.

That is why the 4Ds matter even more as AI becomes more autonomous.

Part 2: The four competencies

3. Delegation: decide who should do what

The most common beginner mistake happens before the first prompt.

People open an AI assistant and start typing without first deciding:

• What am I actually trying to achieve?
• What would a good result look like?
• Which parts should AI do?
• Which parts should I do?
• Which decisions should never be handed over to AI?

That is a Delegation problem.

Delegation means deciding how the work should be divided between the human and the AI.

This is not just "giving work to AI." It is designing the workflow.

Delegation has three parts:

1. Problem awareness: understand the goal and the work.
2. Platform awareness: understand which AI system or tool fits the job.
3. Task delegation: decide who does each part.

(The framework's own reference document calls the first one goal and task awareness. Same idea, and you will meet both names in the wild.)

3.1 Problem awareness: know what you are trying to accomplish

Before asking AI for anything, ask yourself:

• What is the goal?
• Who is this for?
• What does success look like?
• What could go wrong?
• Where is human judgment essential?

Suppose you want an AI agent to chase overdue invoices for a small business.

A beginner might type:

"Build me an invoice-chasing agent."

The AI can produce something. But the hard questions are still unanswered:

• Which customers should it contact?
• How many days late must an invoice be?
• What tone should it use?
• At what amount should a human approve the message?
• What happens if the customer disputes the invoice?
• Which accounting system may the agent read?
• Is the agent allowed to send messages, or only draft them?

These are not prompting questions. They are business questions.

AI cannot decide your business policy for you unless you deliberately give it that authority. In many cases, you should not.

3.2 Platform awareness: choose the right kind of AI

Not every AI system is equally good at every job.

You might choose:

• a reasoning model for a difficult multi-step problem;
• a search-enabled assistant for current information;
• a coding agent for software development;
• an agent-capable system for work that involves tools and multiple steps.

You do not need to memorize every model name. The market changes too quickly.

You do need a habit of asking:

"Is this the right tool for this job?"

Try different systems. Compare their results. Keep notes on what works. Which AI Employees in 2026 provides the book's current map of this changing landscape.

3.3 Task delegation: divide the work deliberately

Once you understand the problem and the platform, split the job into parts.

Suppose you are creating a course like this one:

Task	Best owner	Why
Decide the audience and learning goals	Human	Requires purpose and judgment
Suggest possible course structures	AI + human	AI gives breadth; human chooses
Draft sections from an agreed outline	AI	Fast at first drafts
Verify factual claims	Human	Accountability stays with the author
Add lived experience and local examples	Human	AI does not have your experience
Improve grammar and consistency	AI	Good fit for mechanical review
Approve the final course	Human	Your name and reputation are attached

This is Delegation in practice.

You are asking a better question than "Can AI do this?"

You are asking:

"Which parts should AI do, which parts should I do, and why?"

Where this leads in Agent Factory

Delegation becomes engineering when you build agents for others.

Problem awareness becomes the specification: goal, constraints, risks, and definition of done.

Task delegation becomes the boundary of the Digital FTE: what the agent may do, what humans keep, and what must escalate.

A vertical System of Record makes those decisions durable and inspectable.

Continue in Spec-Driven Development and The FDE AF Model.

4. Description: give AI what it needs

Think back to the colleague from the beginning of the course.

Her course outline was wrong because you left out important information.

AI has the same problem, but more strongly. It cannot read your mind. It only works from the information available to it. If you leave out something important, it may make a reasonable guess. A reasonable guess can still be wrong.

Description is the skill of giving AI the information and guidance it needs to do the work well.

Description is much bigger than "writing a good prompt."

It includes three things:

1. Product description: what you want.
2. Process description: how you want the work approached.
3. Performance description: how you want the AI to behave, both with you and on its own.

A simple memory aid is:

What → How → How to work with me

4.1 Product description: define the result

Product description answers:

"What exactly do I want back?"

Include things such as:

• the type of output;
• the audience;
• the format;
• the length;
• the tone;
• the important topics; and
• anything to leave out.

Compare these two requests.

Vague:

"Summarize this report."

Clearer:

"Summarize this quarterly financial report for senior executives who have ten minutes to read. Focus on revenue trends, major risks, and recommended actions. Use short bullet points and keep it to one page. Highlight any figure that changed significantly from last quarter. Avoid unnecessary accounting jargon."

The second request is not more intelligent. It is more complete.

That is an important beginner lesson:

Completeness usually matters more than clever wording.

4.2 Process description: define the approach

Process description answers:

"How should AI do the work?"

You might specify:

• the steps to follow;
• the order of work;
• the method to use;
• examples to imitate;
• checks to perform before finishing.

For example:

"Review this code for correctness first, security second, and style last. Do not spend time on naming issues until you have checked whether the code actually works."

The desired product is still "a code review." But now you have also defined the process.

Process description matters most when a job has several stages. Suppose you have proposals from three vendors: A, B, and C. You have already written down your criteria, meaning the things that matter most and how much each one counts. You need a recommendation by Friday. Paste all three and ask for "a recommendation," and the AI extracts, compares, scores, and writes in one pass, so the only thing you can check is the ending. In Delegation you split the job by owner. Here you split it by order: send one request per step, and check the result before you send the next.

1. Extract the same facts from every proposal into one table: price, contract length, exit terms (how you can leave), support hours. Check: open each proposal and confirm three or four cells against the source.
2. Compare the vendors on your criteria, using only the table. Check: does every difference it names actually appear in the table?
3. Score each vendor, giving more weight to the things you said matter most. Check: do the scores follow your criteria, or did the AI quietly add a criterion you never asked for?
4. Draft the recommendation. Check: does it claim only what steps 1 to 3 support?

For step 1, the process description is short:

Do only step 1 for now. Put the price, contract length, exit terms,
and support hours from each proposal into one table, then stop.

Extraction goes first because everything later leans on it. A wrong price in the table gets carried through the comparison, the scoring, and the draft, and looks fine by the time you read it. So the general rule is: the step where a mistake would spread the farthest goes first, and you check it before you continue.

4.3 Performance description: define how it behaves

Performance description answers:

"How should this AI behave, and for whom?"

Start with the version you can use today, where the answer to "for whom" is just you.

For example:

• concise or detailed;
• supportive or challenging;
• exploratory or decisive;
• ask questions first or make reasonable assumptions;
• flag uncertainty or simply give the best answer.

A useful performance description might be:

"Challenge my assumptions when they are weak. Flag uncertainty. Do not agree with me just to be polite. If my argument is stronger, explain why. If yours is stronger, hold your position and explain it."

This turns AI from a polite answer machine into a better thinking partner.

That is the small version, the one that fits in a chat window and serves an audience of one: you. The framework means something larger by it. Performance description is defining how an AI will behave, on its own, for the people who will use it, including people who are not you and who will never see the instruction you wrote.

The two are the same skill at two sizes. When you type "do not agree with me just to be polite," you are writing a rule that governs behavior you have not seen yet. A tutoring agent's rule that it must never hand over the answer before the student has attempted the problem is the same sentence with the stakes moved: written once, applied a thousand times, to someone you will never meet.

This is why performance is the part of Description that grows the most as you move from Mode 1 to Mode 2. In a chat, a bad performance description annoys you for ten minutes. In a deployed agent, it is the product.

Description is broader than prompting

AI Prompting in 2026 teaches practical techniques such as giving examples, specifying constraints, decomposing tasks, and defining roles.

This course teaches the larger idea behind those techniques: Description.

Many teams use a prompt template with slots for role, context, task, constraints, and output format. Task, constraints, and output format are product description, and context is what the next section calls context engineering. Add one line for how the work should proceed and one for how the AI should behave with you, and the template covers all three parts.

When you are not sure how to phrase a prompt, do not freeze. Explain your situation in ordinary language and ask the AI to help you turn it into a clearer instruction.

From prompt engineering to context engineering

Prompt engineering asks:

"How should I phrase this message?"

Context engineering asks a bigger question:

"What information must be available for the AI to succeed?"

That information may include:

• documents;
• examples;
• memory;
• conversation history;
• policies;
• tools;
• database records;
• definitions; and
• instructions.

For an agent, this matters enormously.

A beautifully written prompt cannot rescue an agent that has the wrong data, missing rules, poor examples, or no access to the tools it needs.

Where this leads in Agent Factory

Description scales into architecture.

A system prompt can make a performance description persistent. A SKILL.md can make a process description reusable. A System of Record can hold the domain knowledge, rules, definitions, and governance an agent needs.

At that scale, good Description becomes good context engineering.

Continue in System of Context and System of Record.

5. Discernment: do not confuse confidence with correctness

AI often sounds confident.

That is useful for readability. It is dangerous for trust.

A wrong AI answer does not normally arrive with a warning label. It can look polished, detailed, and certain.

So after you describe the work, you need a second skill:

Discernment is the ability to judge the quality of what AI gives you.

Description asks:

"Did I explain the job clearly?"

Discernment asks:

"Did the AI actually do the job well?"

A useful term here is automation bias. It means the human tendency to trust an automated answer too easily, especially when it looks confident or professional.

The failure can look like success

A hallucinated answer may look almost identical to a correct answer. Fluent writing is not proof, a citation-looking link is not proof, and a confident tone is not proof. What you can learn to spot are the four signs a made-up answer usually shows:

• Specifics that are too exact. A precise figure, date, name, or citation that did not come from anything you gave it. "Vendor A delivered 99.97% of orders on time last year" is more suspicious than "Vendor A is reliable," because an exact number looks checked even when nothing was checked. Open the source before you repeat the number.
• Confidence where an expert would hesitate. A question a real specialist would answer with "it depends" comes back as a flat yes with no conditions attached. Ask what would change the answer.
• Contradiction across a long output. Page 2 says the vendor charges a flat fee; page 6 works out the yearly cost from a per-user fee. Long outputs drift, so read the ending against the beginning.
• A claimed action that never happened. "I have sent the email," "I checked the source," "I ran the tests." Unless the tool shows you the sent message, the opened page, or the test log, treat the claim as a sentence, not an event.

When accuracy matters, verify.

Discernment mirrors Description. It has the same three parts, pointed at the same three things:

1. Product discernment: is the result any good?
2. Process discernment: is working this way with AI actually paying off?
3. Performance discernment: when AI acts on its own, are the people on the other end well served?

5.1 Product discernment: is the result good?

Ask:

• Is it factually correct?
• Did it follow every important requirement?
• Is anything missing?
• Is it internally consistent?
• Would an expert find it credible?
• Would I put my name on it?

Those six questions check the answer against three different references, and naming the three keeps the check complete. You check against what you asked for: were the requirements followed, is anything missing. You check against the source material: is it factually correct, is it consistent with the documents on the desk. And you check against your field's standards: would an expert find it credible, would you sign it. An answer can pass two of the three and still fail on the one that matters.

This is where your own domain knowledge becomes extremely valuable.

An accountant notices a bad accounting assumption. A programmer notices a subtle bug. A teacher notices that an explanation will confuse beginners.

AI can increase the speed of expert work. It does not remove the need for expertise.

Judging the result also means judging the case made for it, because an AI can reach the right answer for weak reasons, and a right answer resting on a wrong assumption will not stay right for long.

Suppose that, in the vendor case above, the AI recommends Vendor A over Vendor B. The conclusion may be sensible. But perhaps it assumed Vendor A has a feature that does not exist. You should not trust the recommendation until the support for it holds up.

Useful things to ask the AI to show include:

• assumptions;
• evidence;
• decision criteria;
• calculations;
• intermediate results; and
• alternative interpretations.

Treat these as a justification offered for review, not as a literal transcript of the model's hidden internal reasoning.

For example:

"Before recommending one option, list your assumptions, the evidence supporting them, and the criteria you are using to decide. Then give the recommendation."

This makes the answer easier to inspect.

That prompt asks for the reasoning. When the answer should come from documents you already have, three more lines pin it to them. Suppose the recommendation was meant to come from the three vendor proposals you attached, and the question is which one lets you leave the contract early. Add:

Answer only from the three proposals I attached, not from anything
you know about these vendors. If a proposal does not state its exit
terms, say so instead of guessing. For every term you report, quote
the proposal's section heading and the sentence it came from.

The first line tells the model to use only what is in front of it instead of filling gaps from what it learned in training, which is where Vendor A's imaginary feature came from. The second gives it permission to say "it does not say," which a model rarely does unless told it may. The third hands you something you can open and check in a minute instead of re-reading all three proposals. None of this replaces reading the answer. It makes the reading faster, and it makes a made-up answer easier to catch.

5.2 Process discernment: is this way of working paying off?

Sometimes the answer is fine and the working relationship is not.

This is the question people almost never ask, because the output looked acceptable and so the session felt like a success. Step back and look at the session itself rather than its last message:

• Is the AI adapting to my feedback, or drifting back to what it did before?
• Is it repeating the same mistake after I corrected it twice?
• Has it become agreeable to the point of uselessness?
• Am I spending every turn repairing the same formatting problem?
• Am I now editing its draft more heavily than I would have written the thing myself?

That last one deserves its own moment of honesty. Twenty minutes of steering that saves you an hour is a win. Twenty minutes of steering that saves you fifteen is a loss you have been counting as a win because it felt productive.

When the process is not working, you have three moves, and they escalate: change the performance description, change the tool, or take the task back. All three are fluency. Only the third one feels like defeat, and it usually is not.

5.3 Performance discernment: is the AI serving people well when you are not watching?

The third kind only exists once you have used agency, so it is the one this book eventually cares about most.

Performance discernment asks whether an AI's independent, user-facing behavior actually produces good outcomes for the people meeting it, which is a different question from whether any single output was correct.

An AI tutor might answer every question accurately and still be a bad tutor, because it hands over solutions the moment a student hesitates and nobody learns anything. A support agent might resolve tickets quickly and still be a bad support agent, because it closes conversations customers did not consider finished.

You cannot see this from inside a chat window. It shows up only in the aggregate: in what users do next, in what they complain about, in the cases that quietly go wrong the same way every time.

Which is the honest reason this kind of discernment turns into infrastructure. There is no way to eyeball a thousand conversations, so you build something that watches them for you.

The Description–Discernment loop

Description and Discernment naturally form a loop:

1. You describe what you want.
2. AI produces something.
3. You inspect it.
4. You explain what needs to change.
5. AI tries again.

This is normal.

Good AI work is usually iterative. The first response is often a draft, not the finish line.

When you give feedback, use this simple pattern:

Problem → Why it matters → Direction

Weak feedback:

"Wrong. Try again."

Better feedback:

"The second section assumes enterprise customers. Our audience is solo founders, so the advice is too expensive. Rewrite that section for a one-person business with a limited budget."

The second version gives the AI something useful to work with.

That feedback also shows a common reason a good draft needs another pass: it was written for the wrong reader. Take one finding from a quarterly report: support tickets doubled this quarter, the team did not grow, and first reply time slipped from four hours to nine. The report asks for two hires and, until they arrive, an oldest-ticket-first rule. Ask the AI to write that finding up twice, once for the board of directors and once for the support team.

For the board it comes back as three sentences: "Tickets doubled and first reply time went from four hours to nine. The team did not grow. Approve two hires or accept nine-hour replies."

For the support team it comes back as: "Tickets doubled this quarter and the team stayed the same size, so nine-hour replies come from the volume, not from you. Two hires have been requested. Until they arrive, work the oldest ticket first."

Same facts, same model, two outputs. The board version is a number, a cause, and a decision. The team version is what changed, why it is not their fault, and what to do on Monday. Neither works for the other reader, and you do not need to start the request over to get the second one. Use the same feedback pattern: "This is for the support team, not the board, so they need to know what to do next week. Rewrite it for them."

Two small habits make this adapting work go faster. First, edit in named passes instead of one general sweep: a clarity pass (does each sentence say one thing the reader can follow), a tone pass (does it sound right for this reader), and a formatting pass (headings, lists, length, the shape the reader expects). Each pass catches what a do-everything read misses. Second, when the stakes justify it, ask for two or three candidate drafts instead of one and edit from the strongest. Improving a good base is faster than repairing a weak one, and the differences between candidates show you what your request left unsaid.

Sometimes better Description is not enough. Discernment may show that the original Delegation decision was wrong. Perhaps you chose the wrong tool. Perhaps the AI should never have owned that part of the task. Perhaps the work needs a human expert.

That is also fluency.

Every review ends in one of three ways. The work goes out, the way the cycling club email gets sent. It goes back with feedback in the pattern above. Or you take the task back, the same move as in process discernment, because the fix needs something only you know. Short names for the three, worth keeping because review checklists everywhere use some version of them: ready to use, needs revision, needs human override. Decide which one before you type the next message. Iterating does not mean going on forever, and naming the ending is what stops the "one more small change" loop that eats an afternoon.

Where this leads in Agent Factory

Discernment becomes evaluation engineering when you build AI systems.

Your manual question, "Is this good enough?", turns into eval suites, production checks, monitoring, sampling, and release gates.

You cannot automate a judgment you have never learned to make yourself.

Continue in Trusting the Checker and Eval-Driven Development.

6. Diligence: use AI responsibly and own the result

The first three Ds help you get better results.

Diligence asks a different question:

"Should I use AI this way at all?"

Imagine a lecturer using AI to draft end-of-term feedback for students.

The writing is excellent. But the lecturer pasted student names, grades, and disciplinary notes into a consumer AI service that the university never approved. The students were not told AI helped create comments that may become part of their academic record.

The output may be good.

The use of AI is still irresponsible.

Diligence means taking responsibility for how AI is used and for what happens to its output.

Diligence has three parts:

1. Creation diligence: make responsible choices before and while creating.
2. Transparency diligence: be honest about AI's role when people need to know.
3. Deployment diligence: verify and take responsibility before the work is used or released.

6.1 Creation diligence: choose tools and data responsibly

Before sharing information with an AI system, ask:

• Does this contain personal data?
• Does it contain confidential company information?
• Am I allowed to put this information into this tool?
• Who can access or retain the data?
• Is this service approved by my organization?
• Are there legal, contractual, or professional restrictions?

The easiest path is not always the responsible path.

Copying a real customer database into whatever AI tool happens to be open may save five minutes and create a serious privacy or compliance problem.

Often the fix is not to give up the task but to strip the data. Take the lecturer at the top of this section. In a tool the university had approved, the lecturer could have removed every name and student ID, kept the grade range and the one behavior worth commenting on, and drafted the feedback from that.

The AI needs the pattern, not the person.

This is called redaction, and it fails in two directions. Take out too much and the task cannot be done: feedback with no grade and no incident in it is not feedback. Take out too little and a combination of details still points at one person: "the only student who missed the week 3 lab" identifies that student as surely as a name does. The test is whether someone reading only what you pasted could work out who it is about. Stripping the data answers the data questions on the list above. It does not answer the tool question.

6.2 Transparency diligence: be honest about AI's role

Not every AI-assisted task needs a public announcement.

But when AI materially affects other people, disclosure may matter.

Examples include:

• academic work;
• hiring decisions;
• customer communications;
• medical or financial advice;
• professional reports; and
• content presented as original human work.

The exact rule depends on the context, organization, law, and professional standard.

A useful principle is:

The more an AI-assisted result affects other people, the stronger the case for transparency.

Transparency does not mean giving away every detail of your workflow. It means not misleading people about AI's role when that role matters.

6.3 Deployment diligence: verify before it leaves your hands

Before AI-assisted work is published, sent, executed, or used in a decision, check it.

The transparency principle above sets the size of the check too: the more people the result will reach or affect, the more checking it needs. So does reversibility: a step that cannot be undone deserves a deeper check than one you can retract.

A note to yourself gets a glance. The welcome email from the start of this course gets a full read. A report to a regulator gets a second reviewer. And anything irreversible, the sent payment, the deleted folder, gets its check before the act, because there is no reviewer after it.

Depending on the task and who it reaches, checking may mean:

• verify facts;
• confirm sources really exist;
• check calculations;
• review bias or unfair outcomes;
• confirm permissions and rights;
• follow organization policy;
• obtain human approval for high-impact actions.

The numbers rule

Any number a decision rests on (a total, a percentage, a headcount) must be computed, never generated. Ask a model to summarize the quarterly financial report from earlier and it does not add up the column the way a spreadsheet does. It predicts what a likely-looking total is, so the total can be wrong while every line item is right. Get the number from a spreadsheet, a calculator, or code the AI ran and showed you, then check the inputs, not the sum: did it use the right rows and the right rate? If a summary arrives with figures and no calculation you can see, ask where each number came from before you forward it. How to make the AI run code instead of guessing is in AI Prompting in 2026.

A powerful final question is:

"Would I confidently put my name on this?"

If the answer is no, the work is not ready.

Sometimes the honest answer is "I am not sure," because the case is unclear rather than plainly wrong. An AI-ranked shortlist of job applicants looks reasonable, but you cannot tell whether it quietly favored graduates of two universities. Before you decide, ask yourself four questions:

1. Who is affected by this result, including people who will never see it?
2. What could go wrong for them, and would they be able to tell?
3. What would a fair outcome look like here?
4. What should be disclosed, and to whom?

If you can answer all four, decide, and write the answers down. If you cannot, escalate the question to the person who owns that decision instead of guessing and sending the work out. Guessing is the one option that turns an unclear case into your mistake.

The most important lesson in Diligence is simple:

AI can automate work. It cannot automate accountability.

If an AI-assisted system makes a harmful decision, the organization operating it still has responsibility. If a coding assistant introduces a vulnerability and an engineer ships it, the engineer and organization still own the result.

Where this leads in Agent Factory

Diligence is why the Agent Factory is governance-first.

At system scale:

• Creation diligence becomes data rules, access control, and approved-tool policy.
• Transparency diligence becomes disclosure and user experience design.
• Deployment diligence becomes evaluation gates, audit logs, monitoring, and human review.

A policy only works if the approved tool is as easy to reach as the one people already have open. The lecturer's consumer service was one click away. If the university's approved tool took a request form and a week of waiting, the lecturer's choice was also a policy flaw, not only a personal one. If you are the one who took the easy path, tell whoever owns the policy where it was hard.

In Mode 2, you are not only practicing responsible AI use yourself. You are building responsibility into a product that other people will use.

Continue in System of Record and Designing the Vertical SoR.

Part 3: Put the 4Ds together

7. The 4Ds as a practical operating loop

You have learned the four competencies separately. Real work mixes them together.

The framework's authors explicitly teach a Description–Discernment loop. For Agent Factory work, this book extends the idea and uses all four competencies as one practical operating loop:

Delegate → Describe → Discern → Be diligent → Repeat as needed

Here is what each part contributes:

• Delegation decides whether AI should enter the work and what it should own.
• Description gives the AI the goal, context, process, and behavior it needs.
• Discernment checks the result and improves the next round.
• Diligence surrounds the whole process with responsibility.

Now watch the loop on one real example.

Example: a bookkeeping Digital FTE

Ayesha is a Forward Deployed Engineer in Lahore. She is helping a small accounting practice in Karachi build a bookkeeping Digital FTE.

The first job they want to automate is monthly bank reconciliation.

Step 1: Delegation

Ayesha does not begin by asking an AI to "build a reconciliation agent."

She first maps the job with the accounting partners.

They decide:

• the agent may match bank transactions to ledger entries;
• the agent may flag unmatched items;
• the agent may draft a reconciliation report;
• humans must approve every journal adjustment;
• humans keep every write-off decision;
• anything affecting a client's tax position stays with an accountant;
• high-value unmatched items escalate to a named person.

Now the boundary is clear.

Step 2: Description

Next, Ayesha gives the system the information it needs:

• the firm's chart of accounts;
• matching rules;
• examples of past reconciliations;
• the report format the partners already use;
• escalation rules;
• definitions of duplicate payments and stale cheques;
• a rule that the agent may never post a journal entry itself;
• a rule that it may never contact a client directly.

This is Description at system scale.

Step 3: Discernment

Ayesha does not assume the agent works because a demo looks impressive.

She tests it against past reconciliations that the firm already trusts.

The team checks:

• how many matches are correct;
• how many incorrect matches slip through;
• whether the right cases escalate;
• whether the agent escalates too much;
• whether performance changes over time.

An accountant also reviews some apparently successful matches, not only the failures. That matters because a system can look safe simply by failing quietly.

Step 4: Diligence

Client financial data stays inside approved infrastructure.

Agent actions are logged.

Clients are told when reconciliation is AI-assisted where disclosure is required or appropriate.

A human partner still signs the reconciliation.

The partner remains accountable for the final result.

That is the 4D loop in practice.

The personal skill has become a system property.

Competency	In a chat	In the Agent Factory
Delegation	Decide what to ask AI to do	Scope the Digital FTE and human/AI boundary
Description	Give instructions and context	System prompts, skills, context engineering, Systems of Record
Discernment	Review the answer	Evals, monitoring, sampling, trusting the checker
Diligence	Protect data and own the result	Governance, permissions, audit, disclosure, human review

The Agent Factory does not replace AI fluency.

It industrializes it.

How this connects to the Four Survival Skills and the 10-80-10 Rule

The 4Ds are the personal-scale version of ideas used throughout this book.

The 10-80-10 Rule becomes easier to understand through the 4Ds:

• First 10%: set direction. Delegation and Description are strongest here. Decide what is worth doing and make the goal clear.
• Middle 80%: orchestrate AI. Description and Discernment repeat continuously as AI produces work and you steer it.
• Final 10%: judge the truth. Discernment becomes critical before anything important ships.
• Across all 100%: act responsibly. Diligence is not a final checkbox. It surrounds the whole workflow.

So when you practice the 4Ds in a chat window, you are rehearsing the same human skills you will later need to build and govern AI systems.

8. Four common beginner mistakes

Most frustrating AI experiences can be traced to one of these failures.

Mistake 1: Prompting before defining the problem

You start typing before deciding what success looks like.

Missing skill: Delegation

Fix: define the goal, the audience, the constraints, and the human/AI split first.

Mistake 2: Treating the first answer as the final answer

You assume a weak first response means the AI is useless.

Missing skill: Description + Discernment loop

Fix: inspect the result, give specific feedback, and iterate.

Mistake 3: Trusting a polished answer because it sounds professional

You mistake fluency for accuracy.

Missing skill: Discernment

Fix: verify important facts, assumptions, calculations, and sources.

Mistake 4: Thinking about privacy or accountability only after something goes wrong

You focus on getting the task done and ignore how the AI is being used.

Missing skill: Diligence

Fix: decide data, disclosure, approval, and accountability rules before deployment.

A beginner checklist you can use every day

Before you ask AI to do meaningful work, run this quick check:

Stage	Ask yourself
Delegate	What is the goal? What should AI do? What stays with me?
Describe	What output, context, method, and behavior does AI need?
Discern	How will I know the answer is correct, complete, and useful?
Be diligent	Is the data safe? Does AI's role need disclosure? Who approves and owns the result?

You do not need to turn this into paperwork for every small task.

The point is to make the four questions automatic.

A short recap before you practice

AI fluency is not the ability to memorize prompts. It is the ability to work with AI effectively, efficiently, ethically, and safely.

You can work with AI in three modes:

• Automation: AI performs a defined task.
• Augmentation: you and AI think together.
• Agency: AI acts on its own toward a goal you set, often for people who are not you.

Across all three modes, the four competencies stay the same:

• Delegation: decide the human/AI split.
• Description: give AI what it needs.
• Discernment: judge what comes back.
• Diligence: use AI responsibly and own the outcome.

If you remember only one sentence from this course, remember this:

Decide what AI should do. Describe the work clearly. Check what comes back. Own what happens next.

Try this now: six prompts

Reading about AI fluency is not enough. Use it.

Open an AI assistant and try the exercises below. You do not need to complete all six in one sitting.

1. Build a 4D plan for a real task

Choose something you genuinely need to do this week.

I need to do this: [describe the task].

Before we start, walk me through the four Ds of AI fluency for it:
delegation, description, discernment, diligence. Ask me one question
at a time, skip any that obviously does not apply, and give me the
plan as a short table at the end.

What to notice: the plan is mostly made of your answers, not the AI's. That is the point. Delegation and Diligence are decisions only you can make, and the AI is useful here for remembering to ask, not for deciding.

2. Use Discernment on a topic you already know

Choose a subject where you have real experience.

Let's discuss [topic I know well].

Talk to me like a knowledgeable colleague, not a lecturer.
As we go, I will watch for three things:
- where you improve my thinking,
- where I need to correct you,
- where my own experience makes me reject your suggestion.

Start by asking which part of the topic I want to discuss.

What to notice: how cheap discernment is when you know the domain. You caught the wrong claim without effort, almost without deciding to. That effortlessness is your expertise doing the work, and it is exactly what you will not have in exercise 3.

3. Feel what it is like to be a non-expert

Now choose something you know almost nothing about.

Teach me the basics of [topic I know little about].
Explain it for a complete beginner and use concrete examples.

At the end, identify the claims in your explanation that I should
verify with a reliable source, and explain why they deserve checking.

What to notice: how differently the same quality of output lands. Nothing here felt wrong, because you had nothing to check it against. Hold on to that feeling: it is what every user of an agent you build will feel, all the time, and it is the honest reason a Digital FTE needs evals rather than trust.

4. Write a performance description

Use this at the beginning of a serious working session:

During this conversation:
- challenge weak assumptions,
- flag uncertainty on factual claims,
- do not agree with me just to be polite,
- ask a clarifying question when an ambiguity would materially change the answer,
- change your recommendation when new evidence supports a change,
- explain why when you disagree with me.

What to notice: how few turns it takes before the difference is obvious, and how quickly the effect fades if you open a new chat and forget to set it again. That fading is the whole reason a deployed agent keeps its performance description in a system prompt rather than in someone's memory.

5. Inspect the justification before accepting a recommendation

Give the AI a real decision you are considering, then add:

Before making a recommendation, list:
1. the important assumptions,
2. the evidence supporting them,
3. the criteria you are using to compare the options,
4. the major uncertainties.

Then make the recommendation.
I want a justification I can review, not just a conclusion.

What to notice: whether any assumption on that list is one you would have accepted silently had it never been written down. That is the one worth checking, and it is invisible when the AI gives you only the conclusion.

6. Run a small project through the full 4D loop

Choose a project you can finish in about an hour: a study plan, tutorial, presentation, proposal, or small coding task.

I want to complete this project using the 4D AI Fluency framework:
[describe the project].

First, help me decide the human/AI division of work.
Then, before each AI-owned task, ask what product, process,
and performance I want.

After each important output, stop so I can evaluate it.
At the end, run a diligence check covering facts, sensitive data,
disclosure, approvals, and anything I should verify before using the work.

When you finish, ask yourself:

Which D required the most effort from me?

That is probably the competency you should practice most.

Quick self-check

Answer these from memory, without looking back. If one of them makes you scroll up, that section did not land yet.

1. What four qualities define AI fluency?
2. What is the difference between automation, augmentation, and agency?
3. What are the three parts of Delegation?
4. What are the three parts of Description?
5. Why can a confident AI answer still require verification?
6. What are the three parts of Discernment?
7. What are the three parts of Diligence?
8. What question can you ask before shipping AI-assisted work?
9. In one sentence, what is the 4D loop?
10. How does Discernment become an engineering practice in the Agent Factory?

Answers

1. Effective, efficient, ethical, and safe.
2. Automation executes a defined task, augmentation works with you as a thinking partner, and agency acts toward a goal with more freedom to choose the steps.
3. Problem awareness, platform awareness, and task delegation.
4. Product description, process description, and performance description.
5. Because AI generates plausible output, and plausible is not the same as correct. Fluent wording does not verify facts, assumptions, or reasoning.
6. Product discernment, process discernment, and performance discernment.
7. Creation diligence, transparency diligence, and deployment diligence.
8. "Would I confidently put my name on this?"
9. Decide what AI should do, describe the work, evaluate what comes back, and take responsibility for the whole process.
10. It becomes evals, monitoring, sampling, review gates, and other ways to test whether an AI system is performing acceptably.

Terms this course adds

The technical vocabulary of the machine lives in What AI Actually Is and the book's Glossary. These are the important terms from this course.

AI fluency. The ability to work with AI effectively, efficiently, ethically, and safely.

The 4Ds. Delegation, Description, Discernment, and Diligence.

Automation. AI performs a defined task from specific instructions.

Augmentation. Human and AI work together as thinking partners.

Agency. AI works toward a goal on a person's behalf and chooses many of the steps itself.

Delegation. Deciding what work should be done, what AI should do, and what humans should keep.

Problem awareness. Understanding the goal, the work, the risks, and what success means before involving AI.

Platform awareness. Understanding which kind of AI system or tool fits the task.

Task delegation. Deliberately assigning parts of the work to humans or AI.

Description. Giving AI the information and guidance it needs to do the work well.

Product description. Defining the output you want.

Process description. Defining how the AI should approach the work.

Performance description. Defining how an AI should behave on its own, for the people who will use it. At chat scale this is your working-style preferences; at system scale it is the standing behavior of a deployed agent.

Discernment. Evaluating whether AI's output, justification, and behavior are good enough.

Product discernment. Evaluating the result itself.

Process discernment. Evaluating whether the way you are working with AI is actually paying off, rather than whether any one output was good.

Performance discernment. Evaluating whether an AI's independent, user-facing behavior produces good outcomes for the people it serves.

Diligence. Taking responsibility for how AI is used and for what happens to its output.

Creation diligence. Choosing tools, data, and AI use responsibly before and during creation.

Transparency diligence. Being honest about AI's role when that role matters to affected people.

Deployment diligence. Verifying and vouching for AI-assisted work before it is used, published, sent, or executed.

Context engineering. Designing the information environment an AI system needs: instructions, documents, tools, memory, policies, examples, and other relevant context.

Automation bias. The human tendency to trust automated output too easily.

Hallucination. A confident or plausible AI output that contains fabricated or incorrect information.

Redaction. Removing the details that identify a person or an organization from data before you give it to an AI, while keeping the pattern the task needs.

Where this leads

You now have the human framework that the rest of Foundations builds on.

Next, AI Prompting in 2026 turns Description into practical habits you can use every day.

How to Think in the AI Era strengthens Discernment and critical thinking.

Later in the build path:

• Spec-Driven Development turns Delegation and Description into an engineering method.
• Trusting the Checker and Eval-Driven Development turn Discernment into evaluation infrastructure.
• System of Record and Designing the Vertical SoR turn Diligence, context, and governance into system architecture.

If you are collecting credentials, see Certifications for the exams this material prepares you for.

Sources and license note

The AI Fluency Framework was created by Rick Dakan, Professor of Creative Writing and AI Coordinator at Ringling College of Art and Design, and Joseph Feller, Professor of Information Systems and Digital Transformation at Cork University Business School, University College Cork. Their course AI Fluency: Framework and Foundations was produced with Anthropic and released under CC BY-NC-SA 4.0. Their reference document, Framework for AI Fluency: Practical Overview Document, is released under CC BY-NC-ND 4.0.

This crash course is an independent explanation of that framework in this book's own words and examples. It is not a copy or an adaptation of their materials. Every competency, sub-competency, and modality definition used here was checked against the authors' Practical Overview Document and the framework's terminology sheet. The Agent Factory mappings, the chat-to-factory scaling of each competency, and the four-D operating-loop framing are extensions for this book. Any errors in those extensions are ours, not theirs.

Read the original as well. It is free, and it is better on the research behind the framework than any summary can be.

• The AI Fluency Framework, the authors' own site, with papers, presentations, and open educational resources.
• AI Fluency: Framework and Foundations, the free 12-lesson original course on Claude Academy, about 3 to 4 hours. Also reachable at anthropic.skilljar.com.
• Framework for AI Fluency: Practical Overview Document, the authors' living reference document and the most precise statement of the sub-competencies.
• The companion courses Teaching AI Fluency, AI Fluency for Educators, and AI Fluency for Students, also free on Claude Academy and OpenCourses.ie.
• The AI Fluency Framework terminology sheet (PDF), copyright 2025 Rick Dakan, Joseph Feller, and Anthropic, released under CC BY-NC-SA 4.0.

---

Flashcards Study Aid

---

Test Your Understanding

The four questions at the top of this course were easy to read and are hard to actually run. These scenarios drop you into other people's work with a decision already waiting. Answer from the reasoning rather than the wording, and note which D each one is really testing.

Checking access...