📋 Ready-to-Copy Solutions

Reset the setup to a blank slate to see what really matters.

Setups accumulate bloat; a reset reveals what remains.

Zero state; eliminate accumulation.

Remove skills, instructions, and configs until only the raw agent remains.

It’s the step that gives you the courage to really cut back.

Full wipe; back up first.

Run tasks with the agent without any harness and see where it stumbles.

Only this way will you know what you actually need to add.

Raw baseline; observe the gaps.

Add back only procedures and skills that address real gaps.

Each piece comes back justified, not out of habit.

Intentional layers; one at a time.

Resist the temptation to put everything back; reintroduce only what’s strictly useful.

Keep context light and performance high.

Minimum viable harness.

Use reset as a sandbox to test a new configuration.

Lets you experiment without worrying about breaking the main setup.

Reset as a lab; rapid iteration.

The complete text of the grill-me skill, ready to save in your setup.

It’s the most reusable artifact in the entire course.

Short skill (4-5 sentences); adversarial interview.

A prompt that makes the agent list the 10 most important decisions in the work.

Focuses the interview on what actually drives the result.

Top 10 decisions; explicit prioritization.

Ask the agent to interview you until it reaches ~98% understanding.

Creates shared understanding before a single line of code.

Trust goal; align first.

Invoke grill-me at the start of any ambiguous or large task.

Replaces plan mode and avoids rework.

Before coding; ambiguous tasks.

Tailor the skill to your project's domain, tone, and constraints.

A custom grill-me asks what matters most to you.

Templating; domain context.

A skill that's too long, vague questions, or skipping the interview because you're in a hurry.

Keeps grill-me from becoming just another ritual with no effect.

Short and specific; don't skip alignment.

Three procedures in sequence: grill-me → two-PRD → to-issues.

Turns a conversation into an actionable backlog without you having to type it out.

Thinking pipeline; brain → backlog.

The adversarial interview that draws out the complete vision in your head.

It’s the pipeline’s entry point: garbage in, garbage out.

Pipeline input; align first.

The skill that turns the interview into a structured PRD.

The PRD is the bridge between the vision and the tasks.

PRD as an intermediate artifact.

The skill that breaks the PRD into issues ready to delegate.

A backlog comes out that agents (or people) can pick up directly.

Pipeline output; tasks that can be delegated.

How one skill’s output feeds the next skill’s input.

It’s the heart of human DRY: chain things together instead of repeating them.

Composition of procedures; output → input.

The checkpoints where you approve each step before moving on.

You direct the pipeline; the agent does the grunt work.

Human checkpoints; hands on the wheel.

The combination of tool and model Matt uses day to day.

A concrete starting point, not a theoretical config.

Claude Code; Opus 4.8 at medium effort.

Run the agent away from the keyboard, isolated in a sandbox.

It’s what unlocks parallel work without you having to babysit it.

AFK; sandbox isolation.

How to configure Sand Castle for agent sandboxes.

It’s a ready-made path, not a Docker puzzle.

Sand Castle; ready-to-use sandbox.

Run multiple agents at the same time, each in its own sandbox.

Multiplies output without multiplying risk.

Fleet in parallel; isolation by instance.

How to recover commits generated by agents in the sandbox.

It’s the step that closes the loop between AFK and your repository.

Pull commits; merge them back.

The streamlined version of the AFK setup for you to run today.

Gets you out of paralysis: start small and grow.

AFK MVP; evolve incrementally.

The minimum structure for a GitHub Actions workflow that calls an agent.

It’s the copyable starting point for cloud automation.

Workflow YAML; triggers and jobs.

The sequence of steps: fetch the code, check types, and review.

Filters out obvious errors before spending the agent on review.

Step-by-step pipeline; type check as a gate.

Have the agent post the review result as a comment on the pull request.

Feedback appears where the team already works.

PR comment; in-context feedback.

A cron that runs a security review every day, scanning parts of the code.

It’s the self-improving system that takes care of itself without you having to remember.

Cron schedule; scope rotation.

Collect what the agent finds and turn it into structured issues.

Closes the telemetry → issue → fix loop.

Structured data; findings become tasks.

When to let the Action merge on its own and when to require human approval.

Auto-merge without criteria is like handing a junior the car keys.

Auto-merge gates; caution by default.

The agent records a walkthrough of the changes with TTS narration.

You review by listening instead of reading diffs line by line.

Video walkthrough; review by audio.

Techniques to get more out of your review with less effort.

Review is the bottleneck; optimizing it speeds everything up.

Lean review; focus on what matters.

The repository where Matt publishes his ready-to-use skills.

It’s the source of the skills cited throughout the course.

Skills repo; copyable starting point.

The site where you can browse and discover available skills.

Makes it easier to find the right skill without digging through GitHub.

Skills catalog; easy discovery.

The command to add a skill to your setup in seconds.

It’s the fastest path from “I saw the skill” to “I’m using it.”

npx CLI; instant installation.

The two concrete actions to start applying the method today.

Ends the course with action, not more theory.

First steps; from knowing to doing.