Appendix B — AI Fluency

Four steps for working with an AI assistant: Delegation, Description, Discernment, Diligence

After this page

Name the four Ds and what each one asks of you
Decide what to hand to the AI and what to keep
Pick a fast or a strong model for the task
Check AI output against your own number
Apply the cycle to a calculation model and a dashboard

The model

AI Fluency is “the ability to work effectively, efficiently, ethically, and safely” with AI systems (Dakan & Feller, 2025). Rick Dakan (Ringling College of Art and Design) and Joseph Feller (University College Cork) break it into four competencies, the 4Ds: Delegation, Description, Discernment and Diligence. Anthropic teaches the framework in free courses, one of them for students (Dakan et al., 2025).

In this module we use the four Ds as four phases of one piece of work. You decide what to hand over, you describe it, you judge what comes back, and you vouch for the result. Description and Discernment form a loop: you describe, judge, describe again, until the output passes your check.

flowchart LR
  A["1 Delegation<br/>What goes to the AI?"] --> B["2 Description<br/>Say what you want"]
  B --> C["3 Discernment<br/>Is it right?"]
  C -- "not yet" --> B
  C -- "passes" --> D["4 Diligence<br/>Vouch for it"]

The 4D cycle: Description and Discernment repeat until the output passes the check.

Think of a head chef with a new kitchen assistant. The chef decides which jobs the assistant takes (Delegation), gives a clear order (Description), tastes the dish before it leaves the kitchen (Discernment), and answers to the guest for every plate (Diligence). The assistant is fast; the name on the menu is still the chef’s.

Three ways of working with AI

The framework distinguishes three modes (Dakan & Feller, 2025). Delegation includes choosing among them.

Mode	What happens	Example in this module
Automation	The AI does a defined task on your instruction	“Turn this formula into a Python function”
Augmentation	You and the AI think and build together, step by step	Designing a productivity model for a new process
Agency	You set up an AI to act on its own, also for others	The quiz-me prompt: a tutor you configure once

Phase 1: Delegation — what goes to the AI?

Decide before you open the chat. Three questions (Dakan & Feller, 2025):

Goal and task. What is the question? What answer would change a decision? Break the work into parts: yours, the AI’s, shared.
Platform. What can this assistant do, and what not? Can it run code? Does it see your file? Does it know the textbook’s numbers? (Usually not exactly.)
Task split. Hand over what is tedious and easy to check: code syntax, plots, formatting. Keep what needs judgement: the question, the formula in words, the expected answer, the interpretation.

Rule of thumb for this module: the formula in words and one hand-calculated result stay with you. Code, charts and layout can go to the AI.

Which model for which task

Models differ in speed and depth. A stronger model costs more time (and often money or quota); use it where reasoning matters.

Tier	Examples (autumn 2026)	Use it for
Fast	Gemini in Colab; “Flash”, “mini” or “Haiku” models; small models in Academic Cloud Chat AI	Explain one line, fix an error message, rename columns, change colours
Strong	Claude Sonnet, GPT-5, Gemini Pro (standard mode); the largest model in Chat AI	Write a function or a full block of cells, build a dashboard
Strong + thinking	The same models with thinking / reasoning switched on; Claude Opus	Plan a model’s structure, find a logic error, review someone’s code

Model names change every few months; the tiers stay. When in doubt: plan and review with the strongest model, type and fix with the fast one.

Phase 2: Description — say what you want

The AI knows nothing about your task beyond what you write. Three kinds of description (Dakan & Feller, 2025):

Product description — what the result looks like: inputs with units, the formula in words, the output, the format (a Python function, a table, a chart), one example with the number you expect.
Process description — how to get there: one step at a time, not everything at once. “First the data, then the function, then a test, then the chart.”
Performance description — how the AI should behave: “Ask me before you assume a value.” “Explain each line in one comment.” “Use plain words for a first-year student.”

A good prompt carries context, task, constraints and a check:

Context. I study operations management. I model the productivity of a process in Google Colab with pandas. Task. Write a function labour_productivity(units, hours) that returns units per labour-hour. Constraints. Plain Python, one comment per line, no extra libraries. Check. With 120 units and 40 hours the result must be 3.0 units/hour. Add a test cell that prints ✅ if so.

Phase 3: Discernment — is it right?

Judge the output; do not admire it. Three kinds of discernment (Dakan & Feller, 2025):

Product discernment — is the result correct and useful?
- Matches your hand-calculated number?
- Units right (per hour, not per shift)?
- Change one input: does the output move in the direction you predicted?
- Edge cases: zero hours, empty rows, negative values?
Process discernment — is the conversation working? Three rounds without progress → start a new chat with a better description, or switch to a stronger model.
Performance discernment — does a configured assistant (e.g. your quiz-me tutor) behave as intended? Does it wait for your answer, or give it away?

Typical AI errors in operations calculations: the code runs, the logic is wrong. Utilization computed against the wrong capacity; hours per shift multiplied twice; the bottleneck picked by processing time instead of load. Only your own number catches these.

Phase 4: Diligence — vouch for it

You hand in the result; you answer for it (Bartnik & Haag, 2025; Dakan & Feller, 2025):

Creation diligence — no personal or confidential data in public tools. For data from a company or from fellow students, use Academic Cloud (servers in Germany) or anonymise first.
Transparency diligence — say what the AI did. In Colab: one markdown cell with the prompt, the model and what you changed.
Deployment diligence — before you hand it in or show it: every number checked, every line of code explainable by you. In this programme you must be able to explain your work orally at any time (see Tools → Principles).

Applied example 1: a calculation model

Task. A productivity model in Colab: three process variants (e.g. moving day with 2, 3 or 4 helpers), labour productivity and multifactor productivity for each, one bar chart.

Phase	What to do	Model
1 Delegation	Write the question and both formulas in words on paper. Calculate one variant by hand. Mode: augmentation for the structure, automation for the code. Keep: formulas, hand result, interpretation. Hand over: code, table, chart.	—
2 Description	First prompt: ask for a model plan only (inputs, outputs, cells, no code). Then one prompt per cell: input table → function → test against your hand result → chart. Give units and your expected number in every prompt.	Plan: strong + thinking. Cells: strong, or Gemini in Colab for short cells
3 Discernment	Test cell prints ✅ for your hand-calculated variant. Predict the direction for one more helper, then run. Check units in the table header. Error message → paste it to the fast model with the cell. Result looks odd → ask a different strong model to review the function line by line.	Fixes: fast. Review: strong + thinking, different provider
4 Diligence	Markdown cell: prompts, model names, what you changed. Re-run the notebook top to bottom. Explain every line to a teammate without the AI.	—

Applied example 2: a dashboard

Task. A one-page dashboard from your model’s results: three KPI tiles (e.g. labour productivity, multifactor productivity, cost per unit), one chart comparing the variants, one filter or slider. Built in Colab with plotly, or as a single HTML file.

Phase	What to do	Model
1 Delegation	Decide on paper: who reads it, which decision it supports, which three KPIs, which chart. Sketch the layout by hand. Keep: KPI choice and definitions. Hand over: layout code, styling, interactivity.	—
2 Description	Give the column names, units and five sample rows, not the whole file. State the reader, the decision, each KPI with its formula in words, chart type, filter, and constraints (one file, no outside data, colour-blind-safe colours, axis titles with units). Ask for a text wireframe first, then the code. Afterwards change one thing per prompt.	Wireframe and first build: strong (long, coherent code). Small edits (labels, colours): fast
3 Discernment	Each KPI tile equals the number in your model’s table. Filter set to “all” gives the totals. Bars start at zero. Every axis has a title and unit. Ask the AI: “Explain how each KPI is computed” and compare with your definitions. Test with one extreme row.	Review of the code: strong + thinking
4 Diligence	Add source, date and “built with AI assistance (model, date)” to the dashboard footer. No personal data in the file. Be ready to explain each KPI and each chart choice.	—