The bench, the syntax, and a machine that cleans up after you.

• M0.1WRITER Power-on self-test~6h

  Install Python 3.14 and make the bench yours: REPL fluency, venv-per-project discipline, pip, VS Code with the Python extension, Ruff wired in, git ready.

  Deliverable — a clean Python bench: a venv you can create, destroy, and recreate without thinking, and a hello-tool that proves the chain.

  python 3.14REPLvenvpipruff
  Briefing

  The play

  Install the current stable Python from python.org/downloads (3.14.x as of this writing; 3.15 lands around October 2026 — the course tracks stable). On Windows, take the python.org installer over the Store version and check "Add python.exe to PATH"; you get the py launcher for free, which is how you address a specific version when several exist.

  py -3.14 -m venv .venv          # every project gets its own venv. every one.
  .venv\Scripts\activate           # (macOS/Linux: source .venv/bin/activate)
  python -m pip install ruff       # tools go IN the venv, not global
  python -m pip list               # know what's on the bench

  Then the editor: VS Code + the Python extension (official walkthrough). One non-negotiable: the interpreter picker (status bar, bottom right) must point at this project's .venv — nine-tenths of "it works in the terminal but not the editor" is that picker. Wire Ruff in as the linter and formatter and let it nag you from day one; its nagging is a free tutor.

  REPL fluency (the actual skill of this mission)

  The REPL is where Python people think. Spend a real hour in it: arithmetic, strings, help(str), dir(list), import this. The 3.14 REPL has colors, multiline editing, and block paste — it's a genuinely good scratchpad now. The habit to build: wondering how something behaves and checking in five seconds instead of searching for a blog post about it.

  Failure modes that matter

  • The Store ghost: on Windows, typing python can open the Microsoft Store instead of Python (App execution aliases). Turn those aliases off, or always use py.
  • Global pip sprawl: installing into the system Python works until two projects disagree. The venv ritual costs ten seconds and prevents the whole disease class.
  • Two interpreters, one confusion: when anything acts haunted, python -c "import sys; print(sys.executable)" tells you who you're actually talking to.

  Prove it

  Write hello.py: greets by name from a command-line argument (argparse, even this small — the habit starts now), and prints which Python it's running under. Run it from the venv, from VS Code, and from a fresh terminal. Three green runs, mission done.

  Reference shelf, all free (verified 2026-08-09)

  • The official tutorial — chapters 1–3 tonight.
  • Packaging User Guide — the venv/pip mental model.
  • Automate the Boring Stuff, 3rd ed. — full book free online; your Arc 0–2 companion.
• M0.2WRITER Phosphor burn-in~5h

  Core syntax through tiny playable toys: a dice roller, a number guesser, mad libs, rock-paper-scissors — types, control flow, functions, collections, and exceptions, each learned by making something you can immediately play.

  Deliverable — a toys/ folder of working single-file games, each one playable by a friend.

  typescontrol flowfunctionscollectionsexceptions
  Briefing

  The play

  One toy per concept cluster, built in order, each one playable the moment it runs:

  • Dice roller — numbers, random, loops, f-strings. Roll 3d6, show each die and the total.
  • Number guesser — while, comparisons, input(), and your first exception: int("banana") raises, and the game must shrug, not die.
  • Mad libs — strings and lists: collect words, slot them into a template, print the disaster.
  • Rock-paper-scissors — dicts as rules (beats = {"rock": "scissors", ...}), functions with real signatures, a best-of-five score.

  Craft bar (hold it even on toys)

  • All code lives in functions; the file ends with the if __name__ == "__main__": guard. It matters in Arc 6; the habit is free now.
  • Names say things: secret_number, not x.
  • Every input() is treated as hostile. Players type garbage. Good toys don't crash; they sass.

  Failure modes that matter

  • Tutorial hell: the trap is watching Python instead of writing it. The tutorial and the book are the reference shelf; the toys are the mission. Stuck twenty minutes? Look it up. Not stuck? Don't.
  • Copy-paste learning: type every line yourself, even from references. The fingers are part of the memory.

  Reference shelf, all free

  • Official tutorial ch. 3–5 — types, control flow, data structures.
  • Automate the Boring Stuff 3e — ch. 1–6 map to exactly this mission.
  • Exercism's Python track — 140+ free drills; do a few between toys as reps.
• M0.3WRITER Open the source~3h

  Create the serpent repo — home of everything you build here — with modern layout (pyproject.toml, src/), push it to GitHub over SSH, and adopt a commit discipline.

  Deliverable — ~/serpent repo with README, pushed; first three commits tell a story.

  pyproject.tomlsrc layoutgit discipline
  Briefing

  The play

  One repo for the whole course: ~/serpent with README.md (what this place is), toys/ (M0.2 moves in), docs/ (specs live here, starting next mission), and — from Arc 1 on — proper packages under src/. Drop in a minimal pyproject.toml now (name, version, requires-python = ">=3.14"): it does almost nothing today and becomes the beating heart of Arc 6's packaging mission. The PyPA tutorial shows the modern shape; you're borrowing its skeleton early.

  Commit discipline (the whole lesson)

  • One coherent change per commit; the message says why, not what.
  • Commit before every experiment, so reverting is casual, not surgery.
  • Branches are free. Anything exploratory gets one.

  Failure mode that matters

  The junk-drawer repo: write the .gitignore before the first commit — .venv/, __pycache__/, *.pyc, and .env before any .env exists (Arc 3's bot token will thank you). A venv committed in week one haunts you in month six.

• M0.4ARCHITECT The janitor~6h

  First architect seat: audit your real Downloads-folder chaos, write the sorting rules spec by hand, then build the organizer — pathlib and shutil do the moving, a dry-run mode prints its plan first, and an undo journal makes every run reversible.

  Deliverable — your actual Downloads folder cleaned by code you trust: dry-run diff shown, undo proven.

  pathlibshutildry-run designloggingundo journal
  Briefing

  The architect seat, defined

  You don't write the script first. You write the spec first, in docs/janitor-spec.md: WHAT folder it works on, the RULES table (extension → destination, plus an "older than 90 days → archive" rule if you dare), the COLLISION policy (same filename already at the destination — rename with a suffix, never overwrite), DRY-RUN as the default (moving is opt-in via --do-it), and the UNDO journal (every move appended as a JSON line: source, destination, timestamp). Then you direct the agent to implement the spec and review the result against it, line by line. The spec surviving contact is the grade.

  The Python in it

  from pathlib import Path
  downloads = Path.home() / "Downloads"
  for item in downloads.iterdir():          # pathlib is the whole API you need
      if item.is_file():
          dest = rules.get(item.suffix.lower())
  # shutil.move for the act; json lines for the journal;
  # logging (not print) for the record — the night shift reads logs.

  Failure modes that matter

  • No dry run: a mover that acts on first run against a real folder is a coin flip with your files. Plan first, print the plan, act only on the flag.
  • The silent clobber: moving report.pdf onto an existing report.pdf eats one of them. Your collision policy exists because the agent's first draft usually won't have one — catching that in review is the mission inside the mission.
  • Testing on the real thing: first runs happen on a copy of Downloads in a scratch folder. This is the sandbox habit, and every Tryout in the course stands on it.

  Prove it

  Dry-run on the copy; read the plan; run for real on the copy; spot-check; run undo; verify everything came back. Only then point it at the real Downloads. The building's first real job, and it's reversible.

Your first game loop, your first review, your first PR, your first hire.

• M1.1REVIEWER Shadow the old operator~4h

  Read real idiomatic Python, decision by decision: a small respected codebase against PEP 8 and Python idiom, and file your objections.

  Deliverable — written attacks on at least two of the codebase's decisions, in your Arc 1 notes.

  PEP 8idiomscode reading
  Briefing

  The reviewer seat, defined

  Reviewing is not reading; it's interrogation. For every choice the code makes, ask the three reviewer questions: What does this actually do? What input or future change breaks it? What would I have done, and can I defend the difference? "It's fine" is a failed review; nothing is fine.

  The codebase (it ships inside your install)

  The standard library is on your disk, written by the people who wrote the language. Find it:

  python -c "import textwrap; print(textwrap.__file__)"
  python -c "import json.tool; print(json.tool.__file__)"

  Read textwrap.py end to end (~500 lines of very idiomatic Python: a class doing real work, docstrings, edge-case handling with comments explaining why), then json/tool.py (~80 lines: a complete command-line program — argparse, files, a main()). Keep PEP 8 open and note every place the stdlib itself bends its own style guide — those are the most interesting finds.

  Why this is mission one of the arc

  From here on you'll read far more code than you write — every agent session is a code review. Training the reflex on code this good calibrates your ear: when the agent's output sounds different from textwrap, you'll hear it.

  File objections like

  • "This method is 60 lines and does three jobs — where would I split it, and would my split survive its edge cases?"
  • "This variable name lies a little. What would tell the truth?"
• M1.2WRITER The snake, by hand~6h

  Build Snake on the green screen, no engine: the game loop, tick rate, non-blocking keyboard input, collision, score. This is where the SERPENT earns its name.

  Deliverable — playable Snake in any terminal, written entirely by you.

  game looptick ratekeyboard inputcollisionterminal rendering
  Briefing

  Mental model

  Every game ever shipped is this loop: read input → update state → render → wait for the next tick. Snake is the smallest game that makes you build all four honestly. State is a deque of body cells, a direction, and a food position; everything on screen is a projection of it.

  The two hard parts, named up front

  • Non-blocking input. input() waits; games can't. Install readchar (small, cross-platform, alive — v4.2.x) and run it in a reader thread that pushes keys into a queue.Queue; the game loop drains the queue each tick and never blocks. That's threads, queues, and input handling in one honest lesson.
  • Flicker-free rendering. Print cell-by-cell and the screen tears. Build each frame as ONE string (rows joined with newlines), move the cursor home with the ANSI escape "\x1b[H", print once per tick. Hide the cursor during play ("\x1b[?25l"), and restore it in a finally: — a crashed game must not leave the terminal broken.

  The tick

  import time
  TICK = 0.12                       # seconds per frame — the difficulty dial
  next_tick = time.monotonic()      # monotonic, never time.time, for game clocks
  while alive:
      next_tick += TICK
      handle(keys.drain()); step(); draw()
      time.sleep(max(0, next_tick - time.monotonic()))

  Failure modes that matter

  • The 180° insta-death: pressing left while moving right must be ignored, not fatal. Every first Snake has this bug; finding yours is a rite.
  • Sleeping a fixed TICK instead of sleeping until the next tick — the game slows down as frames get expensive.
  • Windows terminals: use Windows Terminal (ANSI on by default), not the legacy console.

  Prove it

  A friend plays it without instructions from you, dies, says "one more," and the terminal is intact afterward. That's the ship bar.

• M1.3WRITER House rules~5h

  State and persistence, by hand: JSON high-score table, a settings file, a difficulty curve, pause and resume. The cabinet starts remembering its players.

  Deliverable — the arcade remembers you between sessions: scores, settings, and all.

  jsonfile I/Ostate designsettings
  Briefing

  Mental model

  Persistence is a round trip: in-memory state → serialize → disk → deserialize → the same state. Design the state first — a @dataclass for settings (tick speed, board size), a list of score entries (name, score, date ISO-stamped) — then the JSON is just those shapes written down. Add a "version": 1 field today; future-you gets to migrate instead of crash.

  The one professional trick this mission exists to teach

  Atomic writes. If the game crashes mid-write, a naive open(..., "w") leaves a half-file and the scores are gone. Write to a temp file in the same directory, then os.replace(tmp, final) — the OS swaps whole files, so readers see old-or-new, never half. Three lines, and it's the same move every database you'll ever meet makes underneath.

  And the mirror of it

  Loading trusts nothing: file missing → defaults; JSON malformed → defaults plus a warning line (the file was probably you, mid-experiment); unknown version → say so. A corrupt save must never kill the game.

  Failure modes that matter

  • Pause that isn't: 'p' must stop the update, not the loop — input still drains (or unpausing can't work), time accounting resumes cleanly.
  • Schema drift: you'll add a field next week. The version key and defaults-on-missing make that a non-event.
• M1.4REVIEWER The contractor's first diff~4h

  Claude Code's first feature on your codebase: a ghost replay of your best Snake run, on a branch, reviewed like money depends on it.

  Deliverable — a merged (or rejected) PR with your written review; at least one demanded change.

  PR reviewbranchesdiffs
  Briefing

  Setup

  Point Claude Code at ~/serpent and ask for the feature as a spec, not a vibe: record each run as its starting RNG seed plus the sequence of (tick, direction) inputs; on a new game, replay the best run's inputs through the same game rules to draw a dim "ghost" snake in the background. Demand: a branch, a small diff, no rewrite of your loop — the ghost is a layer, and if the agent claims it must restructure your code to add it, that claim is the first thing you interrogate.

  The review discipline (use it forever)

  1. Read the diff cold before running anything. Line by line. Out loud helps.
  2. For each hunk: what does it do, what breaks it, does it belong in this PR?
  3. Run it. Then feed it garbage: a recording from a different board size, a truncated recording file, a seed that isn't an int.
  4. Demand at least one change, even on good code. Finding it is the exercise.
  5. Merge only what you can defend line by line. You are the reviewer of record.

  Why a ghost, specifically

  Deterministic replay only works if the game is honestly deterministic — same seed, same inputs, same ticks, same outcome. If the ghost drifts from the wall it died on, your game loop has a hidden dependency on wall-clock time or input timing, and the ghost just found it. The feature is a test in a costume.

• TRYOUTHIRE #1 Tryout: the Typist~5h

  Your first daemon, deliberately low-stakes: an agent builds a typing-speed cabinet (WPM, accuracy, high scores). You run the full Tryout format for the first time and make the call.

  Deliverable — a second cabinet on the floor, and one page of tryout notes.

  tryout formatreading agent codeacceptance criteria
  Briefing

  The candidate spec (you write this first — architect muscle)

  A 60-second typing test in the terminal: shows a passage from a local texts/ folder, measures gross WPM (chars÷5 per minute) and accuracy, writes results to a scores file in the same shape as Snake's (one convention, two cabinets), and exits clean on Ctrl-C. Small enough to try out in an evening, real enough to matter.

  The Tryout format (learn it here, reuse at every hire)

  1. Paper round: read the candidate's code cold. Note every question before running anything.
  2. Floor round: run it in a sandbox — a scratch copy of the repo, not the real one. Probe: a tiny 60×15 terminal, a passage with unicode quotes, mashed paste-input, walking away for the full 60 seconds without typing.
  3. Stress question: ask the agent "what happens if X?" for your three nastiest X's, and check its answers against what the floor round actually showed. Where the answer and the behavior disagree, you've learned the most important thing this course teaches.
  4. Ruling: hire / fix-then-hire / reject, with reasons, in writing. Rejections are wins.

  Failure mode that matters

  The polite interview. If the Tryout finds nothing, the Tryout was too soft. There is always something: a WPM formula that counts backspaces as progress, a crash on a passage shorter than the window, division by zero on zero typed chars. Find it.

Scrapers and watchers that work while you sleep.

• M2.1WRITER The periscope~7h

  Scraping by hand: requests and BeautifulSoup pull a real site you actually care about into JSON/CSV — with robots.txt respected, delays between hits, and retries that don't hammer anyone.

  Deliverable — fresh structured data on disk, fetched politely by code you wrote.

  requestsbeautifulsouprobots.txtpolitenessretries
  Briefing

  Authored when you approach Arc 2 — with that month's library versions, not today's. Say "author Arc 2 briefings."

• M2.2ARCHITECT The clipping service~7h

  Architect a watcher framework: a base class, per-source plugins (a price drop, a new release, tomorrow's weather), one config file. You design the shape by hand; the agent writes plugins to your spec; you review.

  Deliverable — three watchers running through one framework whose design you can defend.

  OOPclassesplugin designconfig filesreview
  Briefing

  Authored when you approach Arc 2.

• M2.3ARCHITECT Night shift~6h

  Scheduling for real: the schedule library for in-process loops, the system scheduler (Task Scheduler or cron) for jobs that survive reboots. The watchers run nightly and deliver a morning digest — email or webhook — with logging and retries.

  Deliverable — a digest waiting for you at 7am that you didn't touch.

  scheduletask scheduler / cronsmtplib / webhooksloggingretries
  Briefing

  Authored when you approach Arc 2.

• TRYOUTHIRE #2 Tryout: the Clerk~6h

  An agent builds a new watcher plugin with pytest tests. The Tryout runs it in a sandbox against saved fixture pages — including changed ones: does it fail politely when the site moves, or does it lie?

  Deliverable — the Clerk's badge lit; a new plugin on the night shift with tests you trust.

  pytestfixturesfailure modestryout format
  Briefing

  Authored when you approach Arc 2.

A bot your friends actually talk to.

• M3.1WRITER The switchboard, by hand~6h

  A Discord bot from nothing: developer portal, token kept out of git, the gateway connection, and your first commands — dice, 8-ball, quotes. Async Python arrives here, gently.

  Deliverable — your bot online in your own server, answering your friends.

  discord.pyasync basicscommandssecrets handling
  Briefing

  Authored when you approach Arc 3.

• M3.2ARCHITECT The memory core~5h

  SQLite from the standard library: you design the schema by hand (reminders, per-user scores, a quote archive); the agent writes the queries; you review. No server, no install — the database is a file.

  Deliverable — the bot remembers everything across restarts.

  sqlite3SQL basicsschema designreview
  Briefing

  Authored when you approach Arc 3.

• M3.3ARCHITECT Patch the boards~4h

  Wire the arcs together: Snake and Typist leaderboards post to a channel, the night-shift digest lands in another. The bot becomes the building's voice.

  Deliverable — your friends watch high scores fall without you posting anything.

  integrationscheduled postsembeds
  Briefing

  Authored when you approach Arc 3.

• TRYOUTHIRE #3 Tryout: the Quizmaster~4h

  An agent builds a trivia cog. The Tryout runs it in a sandbox server and plays dirty: spam, ties, cheaters, mid-game leavers. Hire only what keeps score honestly under fire.

  Deliverable — the Quizmaster's badge lit; trivia night runs itself.

  cogsedge casesstate under concurrencytryout format
  Briefing

  Authored when you approach Arc 3.

Your own life as a dataset, charted in green.

• M4.1ARCHITECT Punch the cards~5h

  Architect the data pipeline: pick your real exports (Spotify, YouTube, bank CSV — chosen at briefing time), design the cleaning by hand with csv, dataclasses, and type hints; the agent writes the loaders; you review.

  Deliverable — messy real-life exports flowing into clean typed records.

  csvdataclassestype hintsdata cleaning
  Briefing

  Authored when you approach Arc 4.

• M4.2WRITER The year in green~10h

  The deep build, all by hand: group, aggregate, and rank your own year — then chart it with matplotlib styled phosphor-green-on-black and compose the pages into one generated report.

  Deliverable — a report about your actual life, every number traceable to a line of code you wrote.

  aggregationmatplotlibchart designreport generation
  Briefing

  Authored when you approach Arc 4.

• TRYOUTHIRE #4 Tryout: the Analyst~6h

  An agent builds the same style of report for a second dataset. The Tryout is a correctness eval: you seed the data with impossible dates, duplicate rows, and absurd values — does it notice, or does it lie with a straight face?

  Deliverable — the Analyst's badge lit; a pytest eval harness you reuse every time the data changes.

  evalspytestdata validationseeded corruption
  Briefing

  Authored when you approach Arc 4.

Generative toys — text, images, mazes, an attract mode.

• M5.1WRITER The ghostwriter~5h

  A Markov-chain text generator by hand from a Project Gutenberg corpus: build the chain with dicts, walk it with weighted choice, tune the order until the output gets eerie.

  Deliverable — the SERPENT writes almost-sentences in a dead author's voice.

  dictsdefaultdictprobabilitytext processing
  Briefing

  Authored when you approach Arc 5.

• M5.2ARCHITECT The projector~6h

  Image to ASCII with Pillow: brightness mapping, character ramps, glitch modes — architected as a proper CLI with subcommands, output to terminal, text file, or PNG.

  Deliverable — any photo rendered as green-screen phosphor art.

  pillowbrightness mappingCLI designargparse subcommands
  Briefing

  Authored when you approach Arc 5.

• M5.3ARCHITECT The labyrinth~4h

  A procedural maze, generated and solved live in the terminal: depth-first carving, breadth-first solving, animated so you watch it think.

  Deliverable — a maze that carves itself, then solves itself, before your eyes.

  recursionstacks and queuesgraph searchterminal animation
  Briefing

  Authored when you approach Arc 5.

• TRYOUTHIRE #5 Tryout: the Projectionist~4h

  An agent builds the attract mode: an idle screensaver cycling the arc's toys — ASCII art, maze runs, ghostwriter lines. The Tryout runs it unattended for an hour: no crash, no leak, graceful in a tiny terminal.

  Deliverable — the Projectionist's badge lit; the SERPENT performs when nobody's touching it.

  long-running processesresource disciplinegraceful degradationtryout format
  Briefing

  Authored when you approach Arc 5.

Tests, CI, a shippable package, and a build of your own design.

• M6.1ARCHITECT Robots at the gate~4h

  A pytest suite on your best tools, then GitHub Actions running Ruff and pytest on every push. Robots judge your code before it lands, the way every Python team works.

  Deliverable — a red X you caused, understood, and turned green.

  pytestCI/CDgithub actionssetup-python
  Briefing

  Authored when you approach Arc 6.

• M6.2ARCHITECT Going gold~4h

  Real packaging: pyproject metadata, a built wheel, pipx-installing your best tool on a clean machine. The optional TestPyPI upload is a public act and gates on your explicit go.

  Deliverable — pipx install of your own tool on a machine that has never seen the repo.

  packagingwheelspipxversioning
  Briefing

  Authored when you approach Arc 6.

• CAPALL SEATS The last build is yours~13h

  Design a build this course never imagined: spec it (architect), hand-write its riskiest core (writer), direct the agent through the rest, run your own candidate's Tryout ruthlessly (reviewer/debugger), and stamp it gold.

  Deliverable — a working build of your own design, tagged v1.0, its spec and tryout notes in the repo. That's the diploma, and it runs.

  everything
  Briefing

  Authored when you approach the capstone; the spec you can start daydreaming now.