Who this course is for

Your coding agent is fast. On an existing codebase, fast is not the same as right. Maybe it has built a page nobody asked for, re-created a component your design system already has, or told you everything works when it did not.

A better prompt does not fix that. A way of working does: decide how much process each issue needs, cut the work into pieces you can review, and prove every result with evidence. This course teaches that way of working, one short lesson at a time.

Who it is for

This course is for you if:

• you are a front-end or product developer on an existing codebase, often with a design system;
• you use Claude Code, or you are about to;
• your results are uneven, and you want to know why before you change your setup;
• you have a real issue to ship, and you want to show that it works, not just say so.

I use this method every day as a front-end developer on a production app. The examples come from front-end work, but the method does not depend on it: sizing, slicing and proving apply to any codebase.

This is not a course on building a new app from scratch as fast as possible. It is about work you can prove, on the codebase you already have.

What you will be able to do

By the last lesson, you will be able to:

• size an issue before you start, and give it only the process it needs;
• align with the agent on intent before it writes any code;
• slice larger work into pieces you can review the same day;
• prove that work is done with commands, their output and screenshots, instead of the agent’s word;
• pick the right plugin at each step, from design critique to browser checks;
• take one of your own issues from first read to merged pull request.

The three actors

Everything in the course follows one rule: the agent proposes, checks decide, you judge.

• The agent proposes. It reads the code, finds the facts and writes the change. Its report on its own work is a claim, not evidence.
• Checks decide. Type checks, tests, linters and hooks pass or fail the change. Anything a machine can check, a machine checks.
• You judge. Your attention goes to intent, taste and the diff.

You make your decisions at checkpoints. When an issue needs a plan, you approve it before the agent builds. When the work is done, you run the manual test steps, read the diff and give the green light. Nothing merges without it.

Before you start

You need:

• Claude Code, installed and signed in. The quickstart covers both.
• A codebase you already work on, in git, that you can run locally.
• An issue tracker and pull requests. The lessons use GitHub and its gh command line.
• Comfort in a terminal and with reading a diff.
• One real issue you would like to ship. You take it through the method in the last lesson.

The setup lesson installs the rest: Matt Pocock’s skills, Impeccable, Playwright and Context7.