The Practice Repo

The Practice Repo is the guided reference lane for this site. It is a small but realistic application authored with known imperfections: seeded bugs, missing tests, an undocumented module, and a refactor waiting to happen. Built slices carry ground-truth answer keys, so a learner can check their own work without an instructor. Pending slices are marked below and should be treated as walkthroughs until their runnable surface lands.

Status

The Practice Repo is public and clonable: git clone https://github.com/mrfelixwong/agentic-engineering-triage triage. The labs for Modules 0, 1, 2, 3, and 4 are built and runnable; the remaining module slices are still being added — see the module map below.

Stack

The reference implementation is a Python app: a FastAPI backend with a thin web UI, built as a small application flavored by a large language model (LLM) and an agent loop. The choice rests on four points:

• Python is the default language of AI engineering. The agentic/LLM framework ecosystem (LangChain, LangGraph, CrewAI, AutoGen, Pydantic AI) is Python-first, so the codebase resembles what this audience actually works on.
• Readability. Python has a low cross-population reading barrier among mainstream languages, which matters for a teaching repo learners must navigate quickly.
• Double pedagogy. Because the app is a small LLM/agent tool, built exercises teach agent operation while staying in the AI-engineering domain, without turning the curriculum into a course on building retrieval systems from scratch.
• The thin web UI. It keeps Module 3's visual and browser-validation exercises concrete, which a pure-backend Python repo would lose.

A TypeScript / Next.js variant is the documented alternative for web and product-engineer-heavy cohorts. TypeScript leads general-engineer overlap: it is the most-used language on GitHub by contributor count and the default starting point for Next.js, Astro, SvelteKit, and Remix. It is on the roadmap once the Python version proves the format.

The app

The repo is Triage, a small support-ticket assistant: an LLM classifies an incoming ticket. It is realistic enough to carry the built exercises and small enough to hold in mind at once.

triage/
  app/
    main.py            # FastAPI entrypoint
    llm/client.py      # LLM provider wrapper (model id, retries)
    llm/prompts.py     # prompt templates
    triage/classify.py # core: classify an incoming ticket
    models.py          # pydantic models
  tests/               # pytest; the LLM call is mocked here
  eval/                # offline eval set + runner — the source of truth for prompt changes
  answer-keys/         # ground-truth notes for built slices
  .claude/skills/      # coached skills for selected built slices
  pyproject.toml

This is the layout you get when you clone the repo. The labs work against these files directly.

What's seeded in it

The repo ships with deliberate imperfections. Built imperfections are tied to module exercises and answer keys: a seeded classification bug (Module 3), a missing CLAUDE.md and tangled file layout (Module 1), an under-specified feature request (Module 2), and a recurring manual workflow worth capturing as a skill (Module 4). Later slices are planned for guardrails, orchestration, compounding, economics, and judgment. Pending slices are named in the map so the lessons can stay honest about what is runnable today.

Status

The Modules 0, 1, 2, 3, and 4 labs are runnable now, in the public repo (github.com/mrfelixwong/agentic-engineering-triage), each with its answer key and, where it helps, a coached lesson skill — see the map below. The remaining module slices are still walkthroughs; use the bring-your-own lane for hands-on work on those until each slice lands.

Module → slice → coached skill

The Triage app is built one module-slice at a time: each shipped module gets the smallest runnable piece it needs, rather than a fully-seeded app with nine answer keys up front. Each slice pairs a runnable app surface with a coached instructor skill a learner can run inside Claude Code. Modules 0, 1, 2, 3, and 4 are built; the rest are pending.

Module	Triage slice it needs	Coached skill	Status
0 — Watch the loop	The app as-is — observe one agent run end to end	— (no coached skill; just run the app)	Built
1 — Context	Missing CLAUDE.md + a tangled layout to navigate cold	/lesson-1-cold-navigation	Built
2 — Spec	Vague request → build a confidence-score feature from a spec	— (self-graded by a test)	Built
3 — Verification	Seeded billing-misroute bug, pytest, eval with a baseline gate	/lesson-3-1-verification	Built
3.4 — Guardrails	The pre-commit gate hardened into a guardrail set	— (pending)	Pending
4 — Skills	A recurring workflow → build a reusable skill	/lesson-4-skills	Built
5 — Orchestration	A divisible refactor that splits across parallel agents	— (pending)	Pending
6 — Granular practice	Reuses the slices above as decimal sub-lessons	(per sub-lesson)	Pending
7 — Economics	Token/cost instrumentation on the classifier path	— (pending)	Pending
8 — Judgment	A change where the agent's verdict needs a human call	— (pending)	Pending

The repo is public at github.com/mrfelixwong/agentic-engineering-triage. Answer keys live in answer-keys/ and the three coached skills that exist so far live in .claude/skills/ — /lesson-1-cold-navigation, /lesson-3-1-verification, and /lesson-4-skills, matching the Built rows in the table above. To run a coached skill, a learner copies it into their own .claude/skills/, or works inside the cloned repo where it already lives, and invokes it in Claude Code.

Feedback loop by built slice

Module	What you run or produce	Where feedback comes from	Done when
0	Watch one agent run on Triage and name the loop steps.	answer-keys/module-0.md and your transcript notes.	You can point to perceive, plan, act, observe, and name the first failure tell.
1	Write a navigational CLAUDE.md.	answer-keys/module-1.md and /lesson-1-cold-navigation.	A fresh agent opens the right file without you naming the path.
2	Turn a vague confidence-score request into a spec and testable change.	answer-keys/module-2.md plus the targeted test.	The field exists, is in range, and the test passes.
3	Fix the seeded billing bug through a red test, eval, and gate.	answer-keys/module-3.md and /lesson-3-1-verification.	pytest passes, python -m eval.run passes, and the gate rejects the regression.
4	Map the harness and capture the repeated verify workflow as a skill.	answer-keys/module-4.md and /lesson-4-skills.	The map names context, tools, permissions, workflow, and check; the skill runs tests plus eval and reports the baseline result.

Where you practice (recap)

Where	Use it to	Self-check
Practice Repo (this page)	Learn each built move against ground truth.	Exact for built slices: a known bug surfaces, a test goes green, or an answer key confirms the move.
Your own codebase	Apply the move where it pays off.	A judgment cue rather than an exact key.