AI Features in Software: Classroom Bootcamp
An eight-hour classroom bootcamp on putting LLMs inside a piece of software, safely, taught on the Doodle of Smarter’s web console: the sign-in page’s illustration, which a Smarter LLMClient, the Doodle Editor, chooses each day, and another, the Doodle Artist, draws. The whole feature is open source, in apps/doodle/, and runs on every student’s own platform. During the day students change an AI resource’s behavior without touching code, prompt it from Python, try to break the checks around it, and review its work as the person who has the last word. See Course Formats and Grading for the standard bootcamp day, the grading scale and the course policies, and AI Features in Software for an overview of the subject.
At a Glance
Students |
Python developers who want to add LLM features to software they build. |
Deployment |
Each student runs Smarter from source ( |
Models |
The models that the Doodle’s manifests name, through the instructor’s OpenAI key, and OpenAI’s moderation model. |
Cost |
Under $5 per student in model charges, capped with a Budget. The editor’s prompts are small; the artist’s are larger, and Lab 4 runs it a few times at most. |
Learning Objectives
By the end of the bootcamp, students can:
Decide which parts of a feature a model should do and which code should do, and build the feature’s safe answer first.
Declare a feature’s AI parts as Smarter LLMClients and Guardrails, and prompt them from Python.
Design a model’s request and answer as a validated contract with a menu of choices, and check every answer in code.
Defend a feature against a model’s mistakes with a second model as judge, an allowlist sanitizer and tests in which the model is patched.
Design the human review, audit trail, switches and disclosure that a feature needs before its AI output reaches users.
Technical Prerequisites
Required: Python: functions, classes, exceptions and type hints, and JSON.
Required: Git and a GitHub account, with a fork of smarter.
Required: Docker, and Smarter installed from source, proved working with a screenshot of the sign-in page’s doodle before the bootcamp. See the Smarter Instructor Guide.
Helpful: Pydantic models, Python’s
unittest.mock, reading a Django app, YAML, and having called an LLM API.Not needed: JavaScript or React, machine learning, or SVG. The course reads the Doodle’s React app and SVG, but students don’t write either.
Schedule
The files that the lectures refer to are listed in full under Smarter in the Source Code.
Block |
Min |
Content |
|---|---|---|
1 |
45 |
Lecture 1: The newsroom. A feature as desks: the calendar, the editor, the platform’s
checks, the tone judge, the artist, the sanitizer and a superuser, and which are a model
and which are code. Why the safe answer comes first: phase 1 (commit 0df9280ff)
ships the whole feature with no LLM, and |
2 |
45 |
Lab 1: The editor’s taste. In the workbench, students open the Smarter Doodle Editor, run its example prompts, then write requests that tempt it off the menu. They apply a copy of its manifest under their own name with a different editorial policy, run the same requests through both, and compare the choices and reasons. Produces Assignment 1. |
3 |
45 |
Lecture 2: AI resources as configuration. The editor’s and artist’s manifests: model,
temperature (0.2 and 0.6, and why), system prompt, example prompts, |
4 |
45 |
Lab 2: Prompting from code. In their fork, students write a management command that
builds the editor’s request for a day with |
5 |
45 |
Lecture 3: A menu, not a blank page. |
6 |
45 |
Lecture 4: Judges and sanitizers. What code can’t check: tone. The |
7 |
45 |
Lab 3: Trust nothing. Following |
8 |
45 |
Lecture 5: People, paper trails and switches. Proposed drawings and Preview the week
in |
9 |
45 |
Lab 4: Editor-in-chief. Students run |
10 |
45 |
Lecture 6: Shipping an AI feature. The api contract and the caching fallbacks that keep the page whole while a drawing awaits approval; the React app and its “Drawn by a Smarter AI application” credit; tests with the models patched and saved Wikimedia responses; and the cost of a feature, read from the journal. The blog post’s takeaways as a design review checklist. |
11 |
30 |
Capstone kickoff. Students choose a capstone, and draw their feature’s desks, marking which are a model, which are code and which are a person. |
Smarter in the Source Code
Every lecture, lab and assignment in this course rests on the files and commits below. Every
reference is to the main branch of github.com/smarter-sh/smarter, unless another repository is named, so that students
can open each one during class. Python paths are under smarter/smarter/. The case that runs
through the course is the web console’s Doodle, the illustration on the sign-in page that two
Smarter LLMClients choose and draw each day, described in How Two Smarter LLMClients Create the
Sign-in Page’s Daily Doodle
and in Doodle React Component.
The Feature Without the AI
Topic |
What Smarter does |
Where to look |
|---|---|---|
The app’s map |
The Doodle is an ordinary Django app. Its package docstring lists each module: regions, schedules, the catalog, the planner, the editor, the sanitizer, caching and the api. |
|
The catalog |
Nineteen occasions with artwork drawn and reviewed ahead of time, each a short YAML file
and an SVG of its decorations. A date is fixed, the nth weekday of a month, or a country’s
holiday by name, worked out by the |
|
Regions |
The browser sends its time zone and nothing else. Smarter maps it to one of 12 regions and the visitor’s local date. No IP address is looked up, and nothing about the visitor is stored. |
|
The planner |
The calendar alone chooses each region’s doodle a week ahead: the due theme of the highest priority, or the default. A doodle that a person chose is never replanned. This is the safe answer that the AI parts improve on, and fall back to. |
|
The models |
|
|
The schedule |
A Celery task plans the doodles every six hours from Celery Beat, then asks the editor about
new days. |
AI Resources as Configuration
Topic |
What Smarter does |
Where to look |
|---|---|---|
The editor |
An LLMClient manifest: a model, a temperature of 0.2, a long system prompt that describes the request and the answer, example prompts that are real requests, and two output Guardrails. Its taste is configuration, changed by editing YAML, not by a release. Smarter LLM Client. |
llmclient-smarter-doodle-editor.yaml (example-manifests) |
The artist |
A second LLMClient, at temperature 0.6, whose system prompt describes the base scene in coordinates, the palette, a limit on shapes, and what it must never draw. |
llmclient-smarter-doodle-artist.yaml (example-manifests), base.svg |
Output Guardrails |
The editor’s answer passes OpenAI’s moderation model and a Guardrail that strips a stray code fence so the JSON parses. Smarter Guardrail. |
json-code-fence-output.yaml, moderation-output.yaml (example-manifests) |
Staff only |
|
llmclient-smarter-doodle-editor.yaml (example-manifests) |
Prompting from code |
The platform prompts its own LLMClients through the chat api, as any client would.
|
|
Extracted, not copied |
|
|
Finding the resources |
|
Trust Nothing the Model Says
Topic |
What Smarter does |
Where to look |
|---|---|---|
A menu, not a blank page |
|
|
The contract with the model |
Pydantic models describe the request ( |
|
Every choice checked again |
|
|
Blocked topics |
|
|
Inputs filtered before the model |
Trends come from Wikipedia’s most viewed articles. |
Judges, Sanitizers and People
Topic |
What Smarter does |
Where to look |
|---|---|---|
A judge of tone |
Word lists can’t tell sad news from a festival. |
upbeat-occasion-input.yaml (example-manifests), llm_judge_strategy.py |
Failing closed |
|
|
Asking a Guardrail directly |
|
|
Models that differ |
A model that rejects a parameter, as one rejects the judge’s temperature, is retried once without it. The chat provider and the judge share one list of such quirks. |
|
Generated markup |
The artist’s SVG is untrusted. The sanitizer keeps an allowlist of shapes and attributes,
strips handlers, links, ids, |
|
Two locks on one door |
The page shows artwork with |
|
A person decides |
A drawing is saved as proposed. In the Django admin, Preview the week shows every region’s doodle for every planned day, with who chose it and the editor’s reason, and Approve and Reject buttons. Doodle Editor Runs are the paper trail. |
|
Switches |
The editor, the artwork, the trends and the credit each have a waffle switch.
|
Into the Product
Topic |
What Smarter does |
Where to look |
|---|---|---|
The api |
|
|
The page |
The single-page console’s sign-in pages show the doodle, its caption, and “Chosen by” or “Drawn by a Smarter AI application” with a link that explains how; until release v0.42.10, a React app that Django hosted showed it, with a template tag. Django-React Integration. |
|
Testing with the models patched |
The editor’s and artist’s answers are patched in tests, with a test for every refusal and every failure. The app has well over a hundred tests. |
|
Dangerous input on file |
The sanitizer is tested against saved drawings, one safe, one crowded, one empty and one dangerous; trends against saved Wikimedia responses, so no test needs the network. |
The Doodle in the History
The Doodle was built in three phases, each a commit whose body explains what it adds, how it was tested and what it ran into, so students can watch an AI feature grow from a calendar.
Commit |
Why it is worth studying |
Where to look |
|---|---|---|
Phase 1: a calendar |
The whole feature with no LLM at all: regions, schedules, the catalog, the planner, the api, the React app and the switches. The safe answer comes first. |
|
Phase 2: an editor and an artist |
Two LLMClients, the prompting helpers extracted from |
|
Phase 3: trends and a judge |
Wikipedia trends, the tone check that fails closed, and a fix to every |
|
Credit where it’s due |
The “Learn how” link under an AI-chosen doodle points to the article that explains it. |
Graded Assignments
Assignment 1: The Editor’s Taste
Students apply a copy of the Doodle Editor’s manifest with an editorial policy of their own, such
as science and education only, and run the same requests through both editors, including one
that tempts the model off the menu. They compare the choices and reasons, and say which of them
check_decision() would refuse.
Turn in: the manifest, and a two-page Markdown report with each request, both answers and the analysis.
Criterion |
Pts |
Exemplary |
Developing |
|---|---|---|---|
A working manifest |
4 |
Applies cleanly; the policy is stated in the system prompt, not scattered. |
Edits that contradict the rest of the prompt. |
Evidence |
6 |
Real answers from both editors, pasted as they came. |
Paraphrased, or one editor only. |
Analysis |
6 |
Explains each difference by a line of the prompts, and reads the reasons. |
Lists differences without explaining them. |
The off-menu attempt |
4 |
Shows what the model did, and names the check that would catch it. |
Assumes the prompt is enough. |
Assignment 2: Prompting From Code
Students write a management command in their fork that prompts their copy of the editor for a
day, with editor_request() and the helpers in prompting.py, and prints each decision with
the verdict of check_decision(). The api key it uses must be deleted even when the prompt
fails.
Turn in: a pull request against their own fork, and the command’s output for two days.
Criterion |
Pts |
Exemplary |
Developing |
|---|---|---|---|
Uses the platform |
6 |
Prompts through |
Calls a provider’s SDK directly. |
Parses and checks |
6 |
|
Prints the raw answer. |
Cleans up |
4 |
The api key is deleted on success and failure. |
A key left behind when the prompt fails. |
Follows the code base |
4 |
A |
A script outside the app’s conventions. |
Assignment 3: Trust Nothing
Students write at least six tests that feed crafted answers through parse_answer() and
check_decision() with the model patched: malformed JSON, a choice off the menu, a holiday
when the catalog has a theme, a bad link, a caption that is too long and a blocked topic in
other words. They look for one answer that passes but shouldn’t, and propose a fix.
Turn in: a pull request against their own fork with the tests, their output from the container, and a paragraph on the gap they found, or why they found none.
Criterion |
Pts |
Exemplary |
Developing |
|---|---|---|---|
Cases covered |
7 |
Six or more distinct ways to fail, each asserting the reason given. |
Only malformed JSON and off-menu. |
Isolation |
4 |
No real prompts; the model is patched, as in |
Tests that call the LLM. |
The gap |
6 |
A real gap with a failing test and a fix, or a convincing search that found none. |
“The checks look fine.” |
Runs as shown |
3 |
Output from the container matches the pull request. |
Took the tests’ passing on trust; output not included. |
Capstone Projects
Students choose one. Capstones are due one week after the bootcamp.
Capstone A: An AI Feature of Your Own
Learning objective. Build an AI feature into software, with its AI parts as Smarter resources and its safety in code.
In their fork of Smarter, or in a Django project of their own that prompts a Smarter platform, students build a small feature in which an LLMClient makes a choice or writes something that users see: a tip of the day picked from the documentation, a suggested description for a new resource, or a summary of an account’s week. It must work without the model, give the model a menu or a schema, check every answer in code, record what was asked and answered, and have a switch. A feature meant for Smarter itself must be agreed with the maintainers in a GitHub issue first.
What students turn in:
A pull request against their own fork, with the LLMClient’s (and any Guardrail’s) manifest.
Tests with the model patched, and their output.
A one-page design note: the feature’s desks, what each check guards against, and the cost per day from the journal.
A five-minute demonstration, including one answer the code refuses.
How it is graded (100 points):
Criterion |
Pts |
Exemplary |
Developing |
|---|---|---|---|
A safe answer first |
15 |
The feature works, and says nothing wrong, with the model off. |
Breaks or shows an error without the model. |
Contract and checks |
25 |
A validated request and answer, and every rule of the prompt enforced in code. |
Trusts the prompt. |
AI parts as resources |
15 |
Manifests for the model’s taste; prompted through the platform. |
A prompt string in the code. |
Record and control |
15 |
What was asked and answered is kept; a switch turns the AI off. |
No record, or no way to turn it off. |
Tests |
20 |
Refusals and failures tested, with the model patched. |
Only the happy path, or tests that prompt a model. |
Design note |
10 |
Each check tied to the failure it prevents. |
A description of the code. |
Capstone B: Red Team the Newsroom
Learning objective. Evaluate an AI feature’s defenses with evidence, layer by layer.
On their own platform, students attack the Doodle with at least twenty cases: requests that
tempt the editor off the menu, trend titles written to inject instructions, occasions that are
sad but contain no blocked word, and briefs that ask the artist for scripts, links or a drawing
over the base scene. For each case they record which layer stopped it: the prompt, an output
Guardrail, check_decision(), the judge, the sanitizer, or the person in the admin. They
propose one change, with a test that fails before it.
What students turn in:
A table of the cases, with the input, what each model answered, and the layer that stopped it, or none.
A three-page analysis of where the defenses overlap and where they are thin, citing the code.
A pull request against their own fork with the proposed change and its test.
How it is graded (100 points):
Criterion |
Pts |
Exemplary |
Developing |
|---|---|---|---|
Range of attacks |
20 |
Every layer is tested, with cases a careful attacker would try. |
Twenty variants of one attack. |
Evidence |
20 |
Real answers and editor runs, recorded as they came. |
Results from memory, or assumed from the code. |
Attribution to layers |
25 |
Each case traced to the code or resource that stopped it. |
“It was blocked.” |
The change |
20 |
A failing test, then a fix that makes it pass without breaking the others. |
A suggestion without a test. |
Writing |
15 |
Concise, organized and specific. |
Long or general. |
Recommended Texts
Pre-reading: How Two Smarter LLMClients Create the Sign-in Page’s Daily Doodle and Doodle React Component.
Reference: Chip Huyen, AI Engineering (O’Reilly, 2025), on evaluation, guardrails and the architecture of AI applications.
Reference: John Berryman and Albert Ziegler, Prompt Engineering for LLMs (O’Reilly, 2024), on designing the prompts and answers that software consumes.
In the repository: editor.py, prompting.py and sanitize.py.
Further Study
Official documentation: OpenAI’s structured outputs guide, on making a model answer in a JSON Schema, and the Pydantic documentation, on validating what comes back.
Security: the OWASP Top 10 for LLM Applications, especially prompt injection and improper output handling, and OWASP’s Cross Site Scripting Prevention Cheat Sheet, for the reasoning behind the Doodle’s sanitizer.
Human-AI interaction: Google’s People + AI Guidebook, on designing review, explanation and disclosure, and Saleema Amershi et al., Guidelines for Human-AI Interaction (CHI 2019), eighteen guidelines tested on real products.
Risk management: the NIST AI Risk Management Framework, for the vocabulary that governance teams will use when they review an AI feature.
Standards: the SVG 2 specification, for what an SVG can carry besides shapes, and JSON Schema.
YouTube: the AI Engineer channel, for talks on evaluations, guardrails and LLMs in production, and the PyCon US channel, for talks on Pydantic and testing.
Podcasts: Latent Space, on building with LLMs, and Practical AI, on putting AI into products.
Smarter: articles on blog.smarter.sh related to this course: How Two Smarter LLMClients Create the Sign-in Page’s Daily Doodle, the course’s case; LLM Guardrails in YAML: How Smarter Declares, Orders and Audits Them, on the Guardrails around the editor and its judge; DOMPurify and Markdown: Rendering LLM Output as Untrusted HTML in an Embeddable Chat Widget, on the same problem as the artist’s SVG, in the chat; Build a Slack Bot With a Smarter LLMClient, on another piece of software that leaves the AI parts on the platform; and Django-React Integration, on how the console hosts the Doodle’s React app. The case study Guardrails is a lesson with labs and discussion questions.