
Follow a duplicate webhook retry bug from a failing test to an AI-assisted patch. See why the first green result still misses a race, and how a database guard plus an independent HTTP check changes the verdict.
Download the exercise ZIP, tour its files, run the red and green checks, and send a duplicate HTTP retry. Record evidence showing whether one event produces only one durable database row.
A passing sequential test can hide a broken database guarantee. Compare what the test suite proves with a direct duplicate-row probe, then decide whether the AI fix should be accepted.
Use the short exercise ZIP to run three checks and inspect the database directly. Make an accept-or-reject decision based on the duplicate-row evidence, not the agent's confident summary.
Watch a no-edit ChatGPT plan become a bounded Codex task for a blank-summary validation bug. Compare the agent's change with the unchanged tests and a direct localhost check before calling the work complete.
Explore the supplied project, reproduce the validation defect, write a no-edit plan and a bounded patch request, then run the tests and localhost probe. Finish with a short report explaining what passed and where to stop.
A vague request for “high priority” invites an AI assistant to invent architecture. See how a source-grounded prompt turns the ticket into a concrete behavior contract with testable outcomes.
Learn to ask a read-only repository question that points to specific code and admits what is still unknown. This keeps an implementation plan anchored in the service you actually have.
Watch a coding agent receive permission for one bounded `app.py` edit. Compare the same test suite before and after the patch, then check the behavior through a direct HTTP request.
When an AI answer sounds certain but the code disagrees, a precise counterexample is more useful than “try again.” See how to challenge the claim and inspect the revised answer for new mistakes.
Use the downloadable RelayDesk project to inspect the files, write your own prompt, reproduce the red tests, and make a small patch. Verify the green suite and localhost behavior, then note the unresolved old-database migration risk.
Read actual input, cached, and output token counters alongside failed commands and separately verified tests. Learn what a session receipt can show—and why it is not automatically an API bill or proof of productivity.
Trace the route, policy, and tests for a feature ticket, then compare a selected context note with a much larger fixture dump. Learn to give an assistant enough evidence without treating fewer bytes as proof of token savings.
See how a compact engineering state note preserves decisions, open questions, and a no-patch boundary. A fresh AI session uses the note to continue without forgetting the migration risk.
Tour the student ZIP, reproduce the red baseline, select relevant context, and request a read-only plan. Record usage honestly and leave a state note that another session could use to resume the work.
Examine how coding benchmarks such as SWE-bench and LiveCodeBench are measured and where their results may not transfer to your task. Turn those limits into a local success criterion for the RelayDesk ticket.
Compare two read-only answers to the same fixed engineering prompt using a rubric written before scoring. The example ends in an honest tie, showing why a single response cannot establish a universal winner on price, speed, or quality.
Route reversible questions, behavior changes, and migration-sensitive work differently. Use task evidence, switch triggers, and stop rules instead of treating one model as best for every engineering job.
Use the downloadable benchmark notes and saved answers to score two responses with the same rubric. Build a task-routing matrix, then challenge it with an old-database counterexample.
Trace a priority value from webhook input through storage to the GET endpoint. Turn a filter request into acceptance cases an engineer can test before asking an agent to edit code.
A written prompt does not replace real tool permissions. See how to separate the task contract from CLI sandbox controls, begin with a read-only plan, and set a narrow stop rule before editing.
Start with a failing test suite, inspect the exact bounded request, and follow the agent's code change and test run. Then compare its success claim with independent HTTP checks of the new priority filter.
Inspect the changed source and protected-file hashes before accepting a local teaching patch. A separate old-schema check fails, illustrating why “works on a fresh database” is not permission to release.
Use the student ZIP to inspect the project, reproduce the red baseline, ask for a no-edit plan, and authorize a small patch. Verify tests and requests, then write an evidence-based accept-or-hold decision.
Build acceptance and adversarial tests for the webhook and list behavior. Watch an ordering test fail under a controlled regression so you can tell whether the test genuinely protects the contract.
Follow synthetic webhook data through validation, logs, storage, and response. Inspect the submitted agent request, the red/green evidence, and a bounded fix for unnecessary data exposure.
Use a local 3,000-row fixture to compare an unbounded response with an explicit 100-item page and to check duplicate retries. Interpret the observed timings as local evidence, not a production throughput guarantee.
A first patch passes its written tests, but a separate read-only review finds missed boundary cases. Reproduce the failures, inspect the narrow correction, and see why the release decision still needs explicit limits.
Explore the ZIP's starter, candidate, and reviewed code; reproduce red tests, make a bounded AI request, and inspect the diff. Run mutation and volume probes before writing a release-or-hold decision supported by evidence.
Work through a controlled timeout-and-retry scenario by following one event ID across the caller view, application log, HTTP response, and SQLite row. Use AI to rank hypotheses and name evidence that could disprove them.
Reproduce a failing old-schema test, give a coding agent a bounded repair request, and inspect its one-file migration. Independently rerun the protected suite instead of weakening the test to obtain green.
Turn the patch into a runbook another engineer can follow. Review an agent draft, then rehearse setup, tests, an incident probe, migration, and a synthetic backup restore in fresh copies.
Challenge local success with a second read-only AI review and list the checks still missing for production. See why accepting a teaching reference can coexist with deferring a real release.
Use the student ZIP to reproduce the controlled incident and old-schema failure, submit a bounded repair request, and inspect the patch. Rehearse the runbook and document an evidence-backed release decision.
Inspect inherited code and define the expected first-call, retry, and conflict outcomes before editing. Run the red baseline and turn the change request into a bounded agent task.
Follow the exact submitted request, genuine coding-agent actions, one blocked command wrapper, and a one-file patch. Examine the first green suite alongside an independent HTTP and SQLite probe.
A read-only reviewer finds an extreme-ID case that turns the first green patch into an HTTP 500. Reproduce the bug, request a narrow repair, and present the corrected local result with its remaining limits.
Tour the downloadable files, explain the existing behavior, run the red baseline, and submit your own bounded request. Challenge your first green result, inspect persistence, and write a reviewer-ready report of what you proved and what remains open.
This course contains the use of artificial intelligence.
AI can draft code in seconds. The hard part is deciding what to ask, how much context to provide, and whether the answer survives a real test. If you have ever accepted a plausible AI patch and later found a regression, this course gives you a practical engineering workflow for doing better.
You will work through a small, synthetic Python web service called RelayDesk. The course shows the actual requests made to AI assistants and coding agents, edited into readable evidence walkthroughs. You will see a duplicate-event bug, a first green patch that still misses a database invariant, a bounded feature request, an old-schema failure, a review-found boundary bug, and an evidence-backed capstone handoff. These are local educational exercises, not claims about a production service or a human typing live on screen.
Here is what you will practice:
- Turn vague requests into prompts with a clear task, relevant context, constraints, and verification criteria.
- Give an agent enough repository evidence without dumping unrelated files; measure usage and avoid confusing session token counts with an API bill.
- Read coding benchmark methodology, identify what a leaderboard cannot prove, and run a fair local comparison on your own task.
- Limit an agent's authority, inspect its changes, reproduce red tests, and independently verify the result.
- Find flaws that a green test suite misses: database uniqueness, old schemas, data exposure, pagination, retries, and boundary behavior.
- Write a runbook and a release decision that distinguish a locally working teaching reference from a production-ready change.
Each section includes a guided practice video and a downloadable project ZIP. You can inspect the folders and files, run the supplied checks, write your own AI request, compare your result with a reference, and record the evidence you would show another engineer. The final capstone combines prompt design, implementation, adversarial review, repair, and a clear statement of remaining risk.
The course is intentionally focused on engineering judgment, not model hype or a promise of autonomous deployment. The examples use a local coding-agent workflow and a synthetic Python service; the principles transfer to other assistants and stacks. Interfaces, model rankings, and prices can change, so you will learn how to evaluate them rather than memorize a fixed winner.
This course is a good fit if you can read a small codebase and run basic terminal commands. You do not need prior professional experience with AI. Bring a computer, Python for the exercises, and optional access to an AI assistant if you want to perform the agent steps yourself. You can still follow the included evidence without a paid model account.
My goal is for you to finish with a repeatable loop: define the task, choose the evidence, write a bounded request, inspect the output, challenge it, and hand off what you can actually prove.