Capstone: run the whole loop, then prove the work

Nine lessons of pieces become one loop today, run end to end on a real store, with a real bug in it, and a decision at the end that you make out loud.

The capstone

Work against my practice store, Tumble Kitchen. It makes one promise worth testing: the code IRIE20 gives 20% off orders of 10,000 JMD or more. Run the full loop on that promise:

1. Draft with the agent. Ask your coding agent for three tests of the discount boundary: just below 10,000, exactly 10,000, and just above. the Full Jerk Combo at 8,200 plus the Baked Cheese Patty at 1,800 lands the cart at exactly 10,000. No coding agent at work yet? Run the Day 6 plan prompt or the Day 7 boundary prompt in any chat and write the three tests from its output. The loop still works.
2. Review with the fence. Scan the drafts for the eight fence items from Day 4, then ask the Day 8 question of each test: what real product bug would make this fail?
3. Send back with specifics. At least one draft will deserve it. Line numbers, the exact change, a hard stopping point.
4. Encode the corrections. Take your three best corrections from this course, today’s included, and put them in an AGENTS.md at the repo root as checkable rules. That file is the most durable thing this course leaves you.
5. Run the tests. If your boundary test at exactly 10,000 is honest, it goes red, because the store has a real bug there: the promise says 10,000 or more, and exactly 10,000 gets nothing. No suite to run them in? Run the three checks by hand against the store; the cart at exactly 10,000 shows the bug on screen, and what you see is your failure output. Either way, do not fix the test to agree with the product. The evidence is the point.
6. Decide what merges. Out loud: which tests stay in the suite, and why.
7. Write the release note. Use the release summary template: what you tested, what you found, the open bug, and your recommendation.

Workflow

1. Draft
2. Review with the fence
3. Send back
4. Encode
5. Run
6. Decide
7. Release note

The rubric

Check your own work before you call it done:

• Every kept test would fail for a real product problem and names the behaviour it proves.
• No fence item survives in anything you kept.
• Your send-back has line numbers and exact changes, not “make it better”.
• Your AGENTS.md rules are checkable: someone could look at a diff and say pass or fail.
• The red test at exactly 10,000 stays red, and the bug is written up as evidence, not patched over.
• The release note takes a position a teammate could disagree with. That is what makes it useful.

If all six hold, you did not spend ten days learning about AI in QA. You ran an AI-assisted QA practice, with the judgment exactly where it belongs.

The assessment and reviewed certificate

The course ends the way a course should: you prove it. Your final email contains a private code tied to this course and email address. Use it for 25 scenario questions covering access, rules, planning, evidence review, and human release judgment. You need 20 correct overall and at least three correct in every section.

• The questions are timed: 40 minutes, with the countdown on screen.
• Expect more than one format: pick one, pick two, put steps in order, and read the evidence before you answer.
• The practical work is untimed. Prepare it before you start the questions.

Then complete three applied responses and submit the safe demo work: the context map, rules or skill, bounded task, output evidence, corrections, and human release decision. I review it against the published rubric. Submission alone does not issue a certificate.

Unlock the assessment with your final-email code

What you are holding now

• A wired agent.
• A rules file with a review fence.
• The method for your first skill.
• A risk-first way to plan.
• A data prompt that returns oracles instead of trivia.
• A send-back discipline.
• Five questions before anything ships.
• A release note that takes a position.

That is a working AI-in-QA practice, and every piece of it came from work I run on real products.

This is the third and final course in the set, and the whole set was building to today. The fundamentals taught you to think like a tester. Automation taught you to make the checks run themselves. This course put an agent inside that system without letting go of a single decision that matters.

If you or your team wants help doing this on real work, my work with me page is open. Otherwise, my newsletter goes out every week, and it is where the practical material lands first, including everything I learn as these tools keep changing under us. See you there.

Thank you for spending ten days with me. Now go make something faster, and keep it honest.