Two-day live intensive · begins Friday, August 14

Agentic Coding Bootcamp

Go from autocompleting to operating: drive a coding agent through real work, verify what it produces, and bound what it can touch. A two-day live intensive with hands-on labs on a real repo, taught by an engineer who built and hired teams at Meta.

Enroll

Six live hoursTen graded labsSmall cohortEx-Meta instructor

What You'll Learn

Nine tools, one job: get real work out of an agent, and be able to prove it came back right. Tools appear only inside the exercise that needs them.

Nine tools, one job: get real work out of an agent, and be able to prove it came back right.

The nine tools:

Permission modes, plan mode, /rewind — decide what the agent may do before it runs, and undo a bad run cleanly instead of arguing with it
CLAUDE.md, /clear, /context — control what the agent reads, which is what actually decides the answer you get back
Subagents and git worktrees — push an oversized log into its own context window, and run two agents at once across a clean seam
Connected tools (MCP) — mount only what a task needs; fifty tools can cost 10–20K tokens before you type a word
Permission rules in settings — a deny list the agent cannot talk its way past, enforced by the tool, not by good behaviour
Hooks and pre-commit gates — a check that refuses the commit, and a hook that blocks “done” until it passes
Evals with a committed baseline — score work that has no single right answer, and hold it to a floor
Diff review that catches test tampering — spot the agent that edited the test instead of fixing the code
Skills and saved commands — package a workflow you keep retyping — you build your own /goal-brief

Starts August 14 · limited seats

One-time purchase. Full refund after the first class if it's not for you.

Who It's For

This is for you if

You already ship code and use an AI agent, and want to go from autocompleting to operating.
You're a tech lead or senior engineer, and your name goes on what others merge.
You're piloting agents for a team and need rules you can defend, not a demo.

The practice code is Python, but nothing taught is Python-only. No AI or machine learning background needed.

It's not for you if

You're learning to code — the course assumes you can read a diff and judge whether a test is honest.
You're after model internals or prompt theory.
You want a tour of features — tools appear only inside the exercise that needs them.

Learn Together

Figuring out agentic workflows on your own is the hard way to do it. This bootcamp runs live, so you learn alongside a small group with an instructor to ask whenever you get stuck.

Learning alone is hard. Learning together is easy.

And the bar is high. Every session is built and taught to the AlgoMonster standard: high-signal, no filler, by professionals who've done this work at the top of the field.

Meet Your Instructor

Taught live by the instructor. No pre-recorded lectures.

Former Director of Engineering at Meta, 20 years in the industry

Two decades building software and leading engineering teams, including a Director of Engineering role at Meta, with hiring, coaching, and running interview loops.

That experience shapes the material: how experienced engineers fold agentic tools like Claude Code into daily work, and what interviewers look for in a system design round. Sessions are live and small, so you can ask questions as they come up.

Ex-Meta Director of Engineering 20 years of experience

Course Outline

Every line below is taught on a slide or run as a lab. Nothing is aspirational.

Session 1 · Live · 3 hours

Operate one run, then design the task

The agent loop and your controls

The four stages — context, plan, act, verify — and which one has no owner by default
Permission modes, set before the run rather than approved during it
/rewind — restore before you retry, instead of arguing the agent out of a bad state
The three failures you can watch for live: plausible-but-wrong, lost context, a loop that stopped converging
Change exactly one thing, and cap retries at two; name the layer that failed — spec, context, or check — before blaming the model

Context engineering

What is already in the window before you type: system prompt, tool names, skill descriptions, memory, CLAUDE.md
CLAUDE.md at repo root — what earns a line, what to cut, tested on a fresh session
Auto memory versus CLAUDE.md: who writes it, when it reloads, how to turn it off
Naming files instead of letting it search — 176,560 → 66,176 tokens on the same question
/clear, /compact, /context — sizing a run to finish before the window fills; subagents for a context-flooding read

Turning a conversation into a goal

Recovering a goal from a messy thread, and revising what the agent proposes
The goal brief: constraints, non-goals, and where your review boundary sits

Assignments · self-paced

Decline an edit, accept a run, and rewind it all
Ask the same question bare and then briefed, and measure the gap
Write a CLAUDE.md, test it against a fresh session, then trim it
On your own repo: score three real tasks for agent-readiness, draft the instruction file and one goal brief

Session 2 · Live · 3 hours

Verify, bound, and decide

Specification

The spec skeleton on every non-trivial task: goal, context, acceptance criteria, constraints, non-goals, verification
Plan first, then critique it — strike scope you did not ask for, and catch the plan that relaxes an assertion while calling itself tested
Acceptance criteria that name a behaviour instead of echoing the request

Verification with machinery

The check ladder: eye → command → gate, until it no longer depends on anyone remembering
Failing test first, then a hook that enforces it — git config core.hooksPath
Read the test diff whenever tests changed: a loosened assertion disables your verification
Evals with a committed baseline; demand the check’s output, not “tests pass”, and say what it did not cover

Judging the artifact

Open the diff every time; the rest is optional
Trust what you can observe over the tone of the summary, and read a returned diff in a fixed order

Bounding the blast radius

A Never-delegate block, and an action budget in the prompt
Anything the agent reads that you did not write is untrusted input
The four homes for a rule — prose advises, a permission rule refuses; deny lists in settings
Scope a delegate’s tools and permissions at spawn; OS-level sandboxing on what a command can reach

Residue, economics, and scale

Package a repeated workflow as a skill or saved command — you build /goal-brief
The task record in one line, written after review, and the economics call it supports
Price the compute before you spend it; escalate in a fixed order when stuck
Parallelise only across a clean seam: worktrees, subagent versus agent team, and why verification must run without you

Assignments · self-paced

Make it green without making it right, then catch yourself in the diff
Install a gate, and watch one commit refused and one admitted
Give the agent a rule it cannot talk past
Run two agents on one project at once, with a trap we planted

How it runs

Before we start

~20 min

Install Claude Code, then let it set up the practice project while you check its work.

Day 1 · live

3 h

Operate one run, then design the task.

Day 2 · live

3 h

Verify, bound, and decide.

The live hours are practice with someone watching, not lectures: comparing your instructions against someone else's, seeing a run go wrong and get fixed, and being told when to step in and when to leave it alone.

Prerequisites

A laptop you can install software on, and a Claude account that can run Claude Code — a paid plan or a Console account (usage during class bills to it). You bring one project of your own to plan against — you only prepare and plan on it, and the agent never changes company code during the class.

How It Works

The first Agentic Coding cohort is forming now. Enroll and your seat is reserved.

Enroll

A one-time purchase secures your seat in the live cohort. Pay securely with Stripe — no subscription, no renewals.

Get the joining details

We'll email you the link and everything you need before the first session on Friday, August 14.

Attend live

Join the live sessions with Q&A. Seats are limited so each cohort stays small, and every session is recorded in case you miss one.

Ready to Join?

A one-time purchase, fully independent of an AlgoMonster membership.

Enroll now

FAQ

Day 1 is Friday, August 14. Once you enroll, your seat is reserved and you'll get the joining details and both session times by email.

Two live sessions of three hours each, plus about twenty minutes of setup beforehand. Sessions are hands-on, and everything is recorded.

No. The practice repo is Python so everyone works on the same code, but nothing taught is Python-specific — the labs are about context, specification, verification, and review.

Not for the live labs, which all run on a public practice repo. The overnight work uses a repo of your own, but preparation only: you rank tasks and write an instruction file, and the agent never changes company code during the class.

Yes — a Claude subscription or a Console account, because the labs run real agent sessions and that usage bills to your account.

That's frequently the lesson. The labs are built on a throwaway clone, and one of them exists specifically so you can watch a guardrail refuse an agent that tries.

Attend Day 1. If it isn't for you, email us and we'll refund you in full — no questions asked.

Your access doesn't expire. Session recordings and materials stay on your account after the cohort ends, so you can go back to them whenever you need.

No. The bootcamp is a separate, one-time purchase, fully independent of an AlgoMonster membership. You don't need a subscription to attend, and buying the bootcamp doesn't give you one.

Coming next

System Design Bootcamp

A repeatable framework for system design rounds: requirements, data at scale, capacity estimation, trade-offs, and how interviewers score you. Not scheduled yet — join the waitlist and you'll hear first when dates and pricing are set.