AI Fluency: framework & foundations
The judgment layer over capability — Delegation, Description, Discernment, Diligence — with runnable decision aids, mapped across the course, and how a lead builds team-wide fluency.
Learning objectives
- Name the four components of AI Fluency and what each guards against.
- Apply Delegation and Description in practice.
- Apply Discernment: judge output critically.
- Apply Diligence and lead fluent AI use on a team.
code/ak8-ai-fluency/. Python runs offline; configs are ready to use.1 · Why a framework essential
Everything so far was capability — what Claude can do. AI Fluency is the judgment layer: collaborating with AI effectively, ethically, and safely. It's what separates using AI from using it well. Four parts — the "4 Ds."
This is the whole lesson in one row: AI Fluency — working well with AI — is four skills, read left to right in the order you use them on any task.
- Delegation — "what to hand off": first decide which parts of a task to give the AI and which to keep for a human.
- Description — "how to ask": once you've delegated, communicate clearly what you want (goal, constraints, an example).
- Discernment — "how to judge": critically check what came back — is it actually correct, not just well-written?
- Diligence — "how to be responsible": own the outcome — transparency, privacy, and no "the AI wrote it" excuses.
- The arrows show these build on each other: better delegation and description up front mean less to fix during discernment later.
In short: Remember them as four questions you ask on every task — What do I hand off? How do I ask? How do I judge the result? How do I stay responsible?
2 · Delegation — what to hand to AI essential
Decide what to delegate and what to keep. Delegate: well-specified, verifiable, or tedious tasks. Keep: judgment calls, work you can't verify, and anything where being wrong is expensive and irreversible — the "should this be an agent?" test (Ch 4), generalized.
delegate.pydef delegate_score(specified, verifiable, reversible, tedious):
"""Higher = safer to delegate. Each input 1-5."""
score = specified + verifiable + reversible + tedious
if score >= 16: return score, "delegate freely"
if score >= 11: return score, "delegate, but verify carefully"
return score, "keep human — or make it more specified/verifiable first"
print(delegate_score(5, 5, 5, 4)) # boilerplate refactor
print(delegate_score(2, 2, 1, 3)) # a fuzzy, irreversible call
(19, 'delegate freely')
(8, 'keep human — or make it more specified/verifiable first')This little program turns the Delegation question — "is this task safe to hand to AI?" — into a number. You rate a task on four qualities, and it tells you whether to delegate freely, delegate with checking, or keep it human. It's a decision aid, not magic; the value is in forcing you to think about the four qualities.
def delegate_score(specified, verifiable, reversible, tedious):defines a reusable recipe (a function). You pass in four scores, each rated 1 to 5: is the task well specified, can you verify the result, is it reversible if wrong, and is it tedious (boring work AI is great at).score = specified + verifiable + reversible + tedioussimply adds the four ratings into a total from 4 (worst to delegate) to 20 (safest).- The
if score >= 16: return ...lines are thresholds: 16+ means"delegate freely"; 11+ means"delegate, but verify carefully"; anything lower falls through to"keep human". Only one branch runs.returnhands back both the number and the verdict. - The two
print(...)lines call the function on two example tasks — aboilerplate refactor(high on every quality) and afuzzy, irreversible call(low on every quality) — and print the results.
What the output means: You get two lines. (19, 'delegate freely') — the boilerplate scored 19, so hand it off. (8, 'keep human ...') — the fuzzy task scored only 8, so a person should own it.
Try this: Change the second call to delegate_score(4, 4, 2, 3) (score 13) and re-run — the verdict flips to "delegate, but verify carefully". That middle zone is where most real work lives.
3 · Description — how to ask essential
Description is communicating intent: context, constraints, examples, and the shape of a good answer — the craft from PE1/PE2, reframed as a fluency skill. Clearer description → less discernment needed later.
A good description includes
- The goal and who the output is for.
- Constraints and non-goals ("don't do X").
- An example of a good answer when format matters.
- How you'll judge success — so the model optimizes for the right thing.
4 · Discernment — how to judge intermediate
Discernment is critically evaluating output: correct? complete? appropriate? Models are fluent and confident even when wrong, so discernment is active — check facts, test code, notice when a polished answer is subtly off. This is why the course insists you verify.
discernment.pydef discernment_pass(output):
checks = {
"facts_checked": output.get("facts_checked", False),
"code_ran": output.get("code_ran", False),
"edge_cases": output.get("edge_cases_considered", False),
"sources_valid": output.get("sources_valid", False),
}
passed = sum(checks.values())
return passed >= 3, [k for k, v in checks.items() if not v]
ok, gaps = discernment_pass({"facts_checked": True, "code_ran": True, "sources_valid": True})
print("trust it?", ok, "| still verify:", gaps)
trust it? True | still verify: ['edge_cases']This aid supports Discernment — judging whether an AI's answer is trustworthy. It takes a record of which verification steps you actually did and reports whether you've done enough, plus exactly which checks are still missing. The point of the lesson: a fluent answer feels true, so you check it deliberately instead of trusting the polish.
outputis a dictionary — a set of labelled yes/no facts about what you verified.output.get("facts_checked", False)reads one fact and safely defaults toFalse("not done") if that fact was never recorded, so a missing key never crashes.checkscollects the four verification questions: were facts checked, did the code actually run, were edge cases considered, and are the sources valid.passed = sum(checks.values())counts how many areTrue(Python treatsTrueas 1).return passed >= 3, [k for k, v in checks.items() if not v]returns two things: whether at least 3 checks passed, and a list of the checks that failed (that[... if not v]is a list comprehension — "keep each namekwhose valuevis False").- The call passes a record with three checks done (facts, code, sources) but leaves out edge cases, then prints the verdict and the remaining gap.
What the output means: trust it? True | still verify: ['edge_cases'] — 3 of 4 checks passed so it clears the bar, but it honestly flags that edge cases were never considered. "Good enough" and "still has a gap" can both be true at once.
Try this: Flip "code_ran" to False (remove it from the call) so only 2 checks pass, and watch trust it? become False — below the 3-of-4 threshold.
5 · Diligence — how to be responsible advanced
Diligence is using AI responsibly: transparency about what was AI-assisted, privacy (no secrets/PII in prompts), IP/attribution, and owning the outcome — the AI doesn't. Connects to security and governance.
6 · Professional — the 4 Ds across the course professional
| D | Maps to | Course sections |
|---|---|---|
| Delegation | agent-vs-workflow decision | Ch 4, AK5 |
| Description | prompt & context engineering | PE1–PE2, AK1 |
| Discernment | evaluation + verify | Ch 5, TQ, AK1 |
| Diligence | security, guardrails, governance | xt1, W6/W14, O4 |
7 · Tech-lead — build fluency on the team tech-lead
A lead makes fluent AI use the norm: delegation guidelines (what the team should/shouldn't hand to AI), shared prompt/Skill libraries (Description), verification gates (Discernment), and responsible-use policy (Diligence). Fluency scales from individual habit to team culture.
fluency.pydef fluency_maturity(team):
dims = {
"delegation_guidelines": team.get("delegation_guidelines", False),
"shared_prompt_library": team.get("shared_prompt_library", False),
"verification_required": team.get("verification_required", False),
"responsible_use_policy": team.get("responsible_use_policy", False),
}
score = sum(dims.values())
level = ["ad-hoc","emerging","practicing","fluent"][score] if score < 4 else "fluent"
return level, [k for k, v in dims.items() if not v]
lvl, gaps = fluency_maturity({"delegation_guidelines": True, "verification_required": True})
print("team fluency:", lvl, "| build next:", gaps)
team fluency: practicing | build next: ['shared_prompt_library', 'responsible_use_policy']The final aid scales fluency from one person to a whole team — the tech-lead view. It checks whether the team has the four practices that make AI use dependable, then names a maturity level and what to build next. Same shape as the other two aids: read some yes/no facts, score them, return a verdict plus the gaps.
teamis again a dictionary of yes/no facts.dimsgathers the four team practices: written delegation guidelines, a shared prompt library (Description), a verification requirement (Discernment), and a responsible-use policy (Diligence) — the four Ds turned into team habits.score = sum(dims.values())counts how many of the four practices exist (0 to 4).level = ["ad-hoc","emerging","practicing","fluent"][score] if score < 4 else "fluent"uses the score as an index into a list of level names — score 0 gives"ad-hoc", score 2 gives"practicing". Theif score < 4 else "fluent"guard avoids reading past the end of the list when the score is a full 4.- The call passes a team that has guidelines and verification but is missing the other two, then prints the level and the list of practices still to build.
What the output means: team fluency: practicing | build next: ['shared_prompt_library', 'responsible_use_policy'] — 2 of 4 practices in place puts the team at "practicing", and it names the two missing pieces to work on next.
Try this: Set all four practices to True in the call and re-run — the level becomes "fluent" and build next is an empty list []. That empty list is the goal: nothing left to add.
Exercise AK8.1 — Score a task and a team
Context: Running the full 4-D loop on one real task — and then on a team — is what turns the framework from vocabulary into practice: delegate deliberately, describe precisely, discern honestly, and own the outcome.
Your task: Take a task you'd give an AI: run delegate.py on it, write a description with all four elements, list your discernment checks, name the diligence obligations, then score a team with fluency.py and pick the dimension to build next.
Requirements:
- Run
delegate.pyon a real candidate task and record the verdict - Write a description with all four elements (context, format, constraints — plus the task itself)
- List the discernment checks you'd apply to the output
- Name the diligence obligations for shipping it
- Score a real or hypothetical team with
fluency.pyand pick the weakest dimension to build next
💡 Hint: Carry one concrete task through all four Ds before zooming out to the team score — the team gap is easier to name once you've felt the individual loop.
🪜 Practice ladder beginner → industry
Six graded exercises, easy to real-world. Try each before opening its solution.
Context: AI fluency rests on four practices — Delegation, Description, Discernment, Diligence — that together cover the full arc of working with AI: decide what to hand over, ask well, judge the result, and own the outcome.
Your task: Map each of the 4 Ds to the question it answers.
Requirements:
- Delegation answers WHAT to hand to AI (and what to keep)
- Description answers HOW to ask — context, format, constraints
- Discernment answers HOW to judge the output — is it correct and good
- Diligence answers HOW to stay responsible — sourcing, ethics, review
- Frame them as an ongoing checklist, not a one-time setup
💡 Hint: Each D is a question, not a step — pair the practice with the question it forces you to ask.
Show solution
Four practices, four questions (pure recall + framing):
def the_4ds(d):
return {
"Delegation": "WHAT should I hand to AI (and what should I keep)?",
"Description": "HOW do I ask — what context, format, constraints?",
"Discernment": "HOW do I judge the output — is it correct and good?",
"Diligence": "HOW do I stay responsible — sourcing, ethics, review?",
}[d]
for d in ("Delegation", "Description", "Discernment", "Diligence"):
print(d, "->", the_4ds(d))The 4 Ds cover the full arc of working with AI: decide what to hand over, ask well, judge the result, and own the outcome. They're a checklist for using AI well, not a one-time setup.
Context: Delegation is a judgement call on capability, recoverability, and stakes — hand over work AI does well where a mistake is catchable, and keep the decisions you must own.
Your task: Write the rule for what to hand to AI versus keep, and apply it to three tasks.
Requirements:
- The rule takes: AI-capable, error-recoverable, and high-stakes-judgement
- High-stakes judgement → keep (the decision is yours to own)
- AI-capable + errors recoverable → delegate
- Otherwise keep (poor AI fit or errors too costly)
- Apply it to three concrete example tasks with differing answers
💡 Hint: Stakes gate everything: even a capable, recoverable task is kept when the judgement is yours to own.
Show solution
Delegate where AI is capable and errors are catchable; keep the high-stakes judgement:
def delegate(ai_capable, error_recoverable, high_stakes_judgement):
if high_stakes_judgement:
return "KEEP — the decision is yours to own"
if ai_capable and error_recoverable:
return "DELEGATE — capable task, mistakes are catchable"
return "KEEP — either not a good AI fit or errors too costly"
print(delegate(True, True, False)) # draft the first version of a doc -> DELEGATE
print(delegate(True, True, True)) # decide whether to fire someone -> KEEP
print(delegate(False, True, False)) # task AI is bad at -> KEEPDelegation is a judgement call on capability, recoverability, and stakes — hand over work AI does well where a mistake is catchable, and keep the decisions you must own. Delegating well is a skill, not an all-or-nothing switch.
Context: Most "bad AI output" is really an under-described request — adding context, format, and constraints collapses the space of acceptable answers down to the one you actually want.
Your task: Turn a weak request into a strong one by adding context, format, and constraints, and name the three levers.
Requirements:
- Start from a vague request and rewrite it
- Add context: who the audience is and why
- Add format: length and structure
- Add constraint: what to avoid and what to use
- Name the three levers explicitly and show the strong version
💡 Hint: Layer the three levers onto the weak ask one at a time — context, then format, then constraints.
Show solution
Three levers turn a vague ask into a precise one:
Weak: "Write about our product."
Strong: [Context] "For a technical audience evaluating our API..."
[Format] "...write a 150-word overview with a 3-bullet feature list..."
[Constraint]"...no marketing superlatives; use our real endpoint names."
def describe(context, fmt, constraint):
return f"{context} {fmt} {constraint}"Adding context (who/why), format (length, structure), and constraints (what to avoid, what to use) collapses the space of acceptable answers to the one you actually want. Most "bad AI output" is really an under-described request.
Context: Fluent output can be confidently wrong, so discernment checks accuracy and grounding, not just fluency — "it reads well" is the trap a real rubric is built to catch.
Your task: Write a rubric that scores an AI output on the dimensions that matter, not just "looks fine".
Requirements:
- Score accuracy — were the claims actually verified
- Score grounding — can the claims be traced to sources
- Score completeness — is anything important missing from the ask
- Score appropriateness — right tone and format for the audience
- Produce a verdict (accept vs revise) and name which dimensions failed
- Make clear fluency alone is not one of the passing criteria
💡 Hint: Score the axes that separate plausible from correct — verified, traceable, complete, fit — and treat "reads well" as no signal.
Show solution
Score the axes that separate plausible from correct:
def discern(o):
checks = {
"accurate": o.get("claims_verified"), # did you check the facts?
"grounded": o.get("sources_cited"), # can claims be traced?
"complete": o.get("covers_the_ask"), # nothing important missing?
"appropriate":o.get("right_tone_and_format"), # fits the audience/format?
}
failed = [k for k, ok in checks.items() if not ok]
return "ACCEPT" if not failed else "REVISE -> " + ", ".join(failed)
print(discern({"claims_verified":True,"sources_cited":True,
"covers_the_ask":True,"right_tone_and_format":True})) # ACCEPT
print(discern({"claims_verified":False,"sources_cited":False,
"covers_the_ask":True,"right_tone_and_format":True})) # REVISE -> ...Fluent output can be confidently wrong, so discernment checks accuracy and grounding, not just fluency — verify the claims, trace the sources, confirm completeness and fit. "It reads well" is the trap; the rubric forces the checks that catch a plausible-but-wrong answer.
Context: Diligence is where accountability lives: the person shipping AI-assisted work owns it regardless of how it was produced, so verification, data-handling, fairness, disclosure, and human review are the practices that keep it responsible.
Your task: Write the pre-ship checklist for shipping AI-assisted work.
Requirements:
- Facts verified against a real source, not the model's assertion
- No secrets or private data placed in prompts or outputs
- A bias / fairness sanity-check for anything affecting people
- Disclosure where context or policy requires it
- A human reviewed and takes responsibility for the result
- Provenance noted so the work can be re-checked later
💡 Hint: Each item is an accountability practice — verify, protect data, check fairness, disclose, and keep a named human owner.
Show solution
Own the outcome: verify, disclose where required, and keep a human in the loop:
Diligence checklist (before shipping AI-assisted work):
[ ] Facts verified against a real source, not the model's assertion.
[ ] No secrets or private data placed in prompts or outputs.
[ ] Bias / fairness sanity-check for anything affecting people.
[ ] Disclosure where your context/policy requires it.
[ ] A human reviewed and takes responsibility for the result.
[ ] Provenance noted so the work can be re-checked later.Diligence is where accountability lives: the person shipping the work owns it regardless of how it was produced. Verification, data-handling, fairness, disclosure, and human review are the practices that keep AI assistance responsible rather than a way to launder unchecked output.
Context: The 4 Ds scale on a team only when each becomes a concrete guardrail — a delegation list, a prompt library, a review rubric, diligence baked into "done" — so fluency travels through shared assets and coaching, not tribal knowledge.
Your task: As tech lead, turn the 4 Ds into team practice: write a one-page policy that says which D each guardrail enforces and how you'd coach it.
Requirements:
- Delegation → a shared "AI-appropriate vs human-only" task list, reviewed as capability changes
- Description → a prompt/template library so good context+format+constraints are the default
- Discernment → a review rubric (accuracy, grounding, completeness, fit) applied before merge
- Diligence → verification + disclosure + human-owner in the definition of done; secrets never enter prompts
- Coaching: pair on real tasks and make "why did you accept this output?" a normal review question
💡 Hint: Turn each D into an artifact a teammate can pick up — a list, a library, a rubric, a definition-of-done rule.
Show solution
Map each team guardrail to the D it operationalizes:
Team AI-fluency policy
Delegation: a shared list of "AI-appropriate" vs "human-only" task classes;
review it quarterly as capability changes.
Description: prompt/template library so good context+format+constraints
are the default, not rediscovered each time.
Discernment: a review rubric (accuracy, grounding, completeness, fit)
applied to AI-assisted deliverables before merge.
Diligence: verification + disclosure + human-owner requirements in the
definition of done; secrets never enter prompts.
Coaching: pair on real tasks, review against the rubric, and treat
"why did you accept this output?" as a normal review question.The 4 Ds scale on a team when each becomes a concrete guardrail: a delegation list, a prompt library, a review rubric, and diligence baked into "done." Fluency then travels through shared assets and coaching, not tribal knowledge — everyone inherits the same good defaults.
✓ Checkpoint — you can move on when you can…
- Name the four Ds and what each guards against.
- Apply delegation + description in practice.
- Judge output with active discernment.
- Uphold diligence and lead team fluency.
Knowledge check check yourself
In the Delegation dimension of AI fluency, which four properties of a task make it safe to hand to AI, and what kind of task should stay human?
Show answer
Why is Discernment described as deliberate rather than passive, and why can't "the AI wrote it" excuse a bad output under Diligence?