Sapienza University of Rome · PhD Soft Skills 2026

Artificial Intelligence,
from the Inside

A six-hour course for doctoral students of every discipline — including those who have never written a line of code, and do not intend to start. Students describe what they want; the machine writes the program. The course is about knowing what to ask for, and knowing when the answer is wrong.

6 hours 176 slides 8 Colab notebooks 0 lines of code written by students no API key · no installation · free tier
Open Module 1 ↗ Open Module 2 ↗ The Playbook ↗

// What this is

Most introductions to AI either assume a mathematics degree or reduce to a tour of products. This one does neither. The morning builds the mental model you need to use these systems well and to recognise when they are failing; the afternoon builds four layers on top of it — chatbot, prompting, grounding, agent — until each student holds a small working research tool.

The examples lean towards text, archives, interviews and historical sources, because the audience is mixed and humanities-heavy. Roughly a fifth of the time is spent on where these systems break: hallucination as a mechanical consequence rather than a bug, shortcut learning, confidence that survives being wrong, and the citations that do not exist.

Everything runs on Google Colab's free tier. There is nothing to install, nothing to pay for, and no API key. No PyTorch appears anywhere — the exercises use scikit-learn and plain Python, and the code is written by Colab's built-in AI from prompts the students supply.

// Slides

Module 1 · 9:00–12:00

Fundamentals: from Machine Learning to Transformers

Rules versus examples. Data, training, evaluation, and the accuracy numbers that lie. Neurons, CNNs, RNNs and what each one cannot see. Then attention, tokens, next-token prediction — and why hallucination is inevitable rather than accidental.

99 slides · with speaker notes
Open the deck → Module 2 · 14:00–17:00

From Models to Tools: Chatbots and Agents

Why a chatbot is an illusion, and a useful one. Prompting as a craft with actual rules. Putting your own documents on the model's desk. Agents: tools, loops, and the six ways they fail. Ends with the bridge to running models on the University's own machines.

77 slides · with speaker notes
Open the deck →
Presenting: the decks are single self-contained HTML files — no build step, no internet, no PowerPoint. Press N for speaker notes, F for fullscreen, Esc for the slide overview. Add ?print-pdf to the URL to export a PDF handout.

// Notebooks

Each notebook gives the student a prompt, an empty cell, and Colab's AI to fill it. Every section also ships with working reference code, so anyone who would rather watch than type loses nothing. The teaching corpus is embedded directly in each notebook — there is nothing to download.

Click Copy to Drive as soon as a notebook opens. These open read-only from GitHub: they run perfectly, but nothing you do is saved until you copy them.

  • 0

    Warm-up 2 min

    Prove Colab works, and generate your first cell from a prompt.

    Open in Colab ↗
  • 1

    Teach a machine to sort your texts 30 min

    Train a real classifier, compare it to a do-nothing baseline, read its mistakes — then train it on shuffled labels and watch it memorise nonsense.

    Open in Colab ↗
  • 2

    Images, and how to fool them 5 min · demo

    A digit classifier at 97%. Add faint noise: accuracy collapses, confidence does not.

    Open in Colab ↗
  • 3

    Look inside the language model 20 min

    Real tokenisation and the language tax on Italian and Greek. A working next-word predictor with a temperature dial. Then a hallucination produced on purpose, and checked.

    Open in Colab ↗
  • 4

    Build a chatbot with a method 20 min

    Build the transcript machinery, watch the token count grow, write a system prompt for your own field — then try to break your own rules.

    Open in Colab ↗
  • 5

    The prompt tournament 20 min

    One task, four prompts of increasing quality, scored automatically against twenty gold answers. Where prompting stops being an opinion.

    Open in Colab ↗
  • 6

    Question your own documents 25 min

    Extract, chunk, search by meaning, answer with citations you can check — on the provided archive or on your own PDFs.

    Open in Colab ↗
  • 7

    Build your research agent 40 min · capstone

    Four tools, a supervised loop, and a table at the end you can actually use. The tools are real code doing real work; the student stands where the network call would be.

    Open in Colab ↗
On the corpus. The exercises use 264 short letters in the style of a 17th-century Italian correspondence archive. It is constructed, not historical, and the notebooks say so: about one label in eight is deliberately wrong, dates appear in five inconsistent formats, and some letters are in Italian. That is what makes "read the errors" a real exercise rather than a formality.

// Take-aways

The Prompt Playbook

The student take-away: fifteen rules and seven reusable prompts — the structured extraction, the hostile reviewer, the reversed interrogation, the normaliser with a receipt, and the verification prompt that should end every session. Each with the reason it works, because the reason outlives the tool.

Read the playbook ↗

Every prompt in the course

All thirty-five exercise prompts in the order they appear, each with a note on what it is for and why it is worded that way. Generated from the same source as the notebooks, so the two can never drift apart.

Read every prompt ↗

// The thirteen rules, in short

  1. If you can write the rule, write the rule. Using AI where an ordinary rule would do is slower, costlier and less auditable.
  2. Ask whose judgement is encoded in the answers. "Ground truth" is a confident name for somebody's opinion.
  3. Never accept an accuracy number without the baseline and the failure cases.
  4. Ask what it got wrong, and which features it used. Two prompts that turn a black box into something you can judge.
  5. When a model performs suspiciously well, hunt the shortcut before celebrating.
  6. Give it the material. Ask it to transform, not to remember. The single most useful distinction in the course.
  7. Self-checking is worth a prompt and is never verification.
  8. When a conversation goes wrong, start a new one. A bad turn stays on the desk and is re-read as fact.
  9. Write rules as procedures, not prohibitions. "Quote the passage, then interpret it" beats "never invent".
  10. Ask for the evidence before the conclusion. It improves the answer and makes it checkable.
  11. Never accept a first output. Make it attack its own work, then check the attacks.
  12. Test grounded systems on facts you know — including one they should not be able to answer.
  13. Agents are for narrow, repetitive, verifiable tasks at a scale you cannot do by hand. Everything else is a demo.

// Reuse

The slides, notebooks and playbook are free to reuse, adapt and pass on. If you teach a version of this in your own department, I would be glad to hear how it went — and especially which parts failed, since those are the ones worth rewriting.

Source and build scripts on GitHub  ·  fabrizio.silvestri@uniroma1.it