AdapttoAI · Program Syllabus

AI Builder Bootcamp

A four-week guided practice that takes non-technical operators from zero to shipping — building real things, at work, from the first session. Delivered in the agentic CLI your company prefers: Claude Code or Codex.

Lessons 4 live sessions
Duration 4 weeks
Time / week 2 hours
Cohort size Minimum 5
Tools Claude Code or Codex
Follow-up Session after 1 month
Level No code required
How the program works

Before class · ~60 min async

Read, then prepare

Short readings and a quiz sent the week before each live session. Participants arrive knowing the concepts; live time goes entirely to practice.

In class · 75 min live

Watch it run, then run it

The instructor builds in real-time on a real project. Participants approve plans, redirect them, and work exercises on their own project. Q&A closes every session.

After class · ~60 min async

Ship something concrete

Each session closes with a deliverable — a drafted CLAUDE.md, a shipped feature, a skill they wrote. The post-work is productive work, not extra study time.

Before lesson 1

AI Literacy Onramp · Async · ~60 min · Sent one week before kickoff

Arrive warm, not cold

Covers the three concepts every participant needs before L1 begins — how probabilistic AI works, what the context window is and why it matters, and why Claude Code is different from a chat interface. Includes a rewriting exercise and the setup checklist so no session time is spent on installation.

  • Probabilistic AI — outputs vary; iteration is the workflow
  • Context is finite and must be actively managed
  • Chat interfaces vs. agents — the key distinction
  • The harness: Claude reads files, writes files, runs commands, loops
  • First exercise: rewrite one real prompt from your own work
  • Setup checklist: Claude Code CLI + VS Code integration
The four lessons
L1 Live · 75 min

The Planning Mindset

The model is the same for everyone. What changes the outcome is the context and the plan you give it.

  • How AI actually works: probabilistic outputs, context window, chat vs. agent
  • Why Claude Code is different — the harness: read, write, run, loop
  • The approval gate: plan → redirect → approve, demonstrated live on a real project
  • Why planning changes quality: same prompt with and without a plan, side by side
  • The repeatability reflex: after every task, spot what Claude could do every time
  • Tier classification: T1 (just do it) / T2 (plan it) / T3 (gate it) — 5 real tasks live
Details

Before class

  • How AI works: probabilistic outputs, context window, tool landscape
  • Why Claude Code's harness is different — reads, writes, runs, loops
  • Quiz: 5 questions across both readings
  • Setup confirmed: Claude Code CLI + IDE integration

In class

  • Live demo: Claude reads a folder, writes from what it finds
  • The approval gate — plan, redirect, approve
  • Storytelling arc: same prompt with and without a plan
  • The repeatability reflex: spot what Claude could do every time
  • Tier classification: T1 / T2 / T3 tasks demonstrated live
  • CLAUDE.md introduced — light touch, deep dive in Lesson 2

After class

  • Classify 10 real tasks from your work (T1/T2/T3 with one-sentence reasoning)
  • Draft a first CLAUDE.md for your real project — rough is fine; we rewrite it in L2
You leave with A clear mental model of why planning changes output quality, and a first CLAUDE.md draft to refine in Lesson 2.
L2 Live · 75 min

Build on the Plan

A project is made of files. Claude remembers nothing between sessions — the files are its memory. Improving the files is how you improve Claude.

  • Files are the backbone: CLAUDE.md · docs/ · skills — each read at a different moment
  • CLAUDE.md anatomy: Context / Rules / Commands — ≤60 lines, shown on a real project
  • Define done before building: 3 verifiable criteria per phase, every time
  • The build loop: ASCII sketch → HTML mockup → review → build → verify
  • Live skill capture: a repeated gesture becomes a slash command mid-demo
  • Compounding retrospective: close every session by saving what you learned back into the files
Details

Before class

  • Instantiate your project: Claude sets up the folder structure from your L1 plan
  • Have Claude generate your first CLAUDE.md draft (refined in class)
  • Try one tier-1 skill — "Grill Me": Claude asks questions before generating any plan
  • Draft a personal use case to build during the session

In class

  • Files are the backbone: CLAUDE.md · docs/ · skills — each read at a different moment
  • CLAUDE.md anatomy: Context / Rules / Commands — ≤60 lines, why the limit matters
  • Execute in phases: 3 verifiable "done" criteria before building anything
  • ASCII sketch → HTML mockup → review → build → verify → dependency check
  • Live skill capture: a repeated gesture becomes a slash command mid-demo
  • Skill composition: a skill that calls other skills (tier-2 preview)
  • Permission modes: Plan → Manual → Edit → Bypass — a dial, not a setting
  • Compounding retrospective: save what you learned back into the files, every session

After class

  • Build and deploy one real feature using the criteria and sketch from class
  • Complete your CLAUDE.md — under 60 lines, WHY → Constraints → HOW
  • First compounding log entry: one real mistake, why it happened, what changes
You leave with One shipped feature and a working CLAUDE.md. You've run the full build loop — phases, defined-done, mockup-first, verify — on a real project.
L3 Live · 75 min

Skills, Rules & MCPs

By now you've built something real and hit real friction. This is where you capture it as reusable building blocks.

  • Global settings: the ~/.claude layer — what belongs globally vs. per-project
  • Rules files: the silent failure of wrong config — live demo of paths: vs. globs:
  • Tier-2/3 workflow skills: multi-step processes with ordered checks built in
  • Scripts vs. skills: when deterministic code beats AI reasoning every time
  • MCPs live: connect Gmail or Calendar — Claude acts on external tools, not just reads
  • The agentic map: a mother project whose documents other projects reference
Details

Before class

  • Rules files: what they are, why separate from CLAUDE.md, how paths: scoping works
  • Tier-2/3 skills: multi-step, guided, rule-rich workflows vs. tier-1 shortcuts
  • MCPs: the "friction-twice" gate — do you actually need one?
  • Sandbox play: run Claude with bypass permissions in a throwaway project

In class

  • Global settings: the ~/.claude layer — what belongs globally vs. per-project
  • Rules files: the silent failure of wrong config (paths: vs. globs:) — live demo
  • Tier-2/3 workflow skills: multi-step processes with ordered checks built in
  • Scripts vs. skills: when deterministic code beats AI reasoning (decision tree)
  • The agentic map: a mother project whose docs other projects reference
  • MCPs: connect Gmail or Google Calendar live — Claude acts, not just reads
  • Model selection and context management (/model · /context · /compact)
  • Hooks (preview): an event triggers an automatic action — concept introduced

After class

  • Write one rule using paths: — verify it auto-loads, share content + confirmation
  • Write a skill for a workflow you already did manually in Lessons 1–2
  • Connect one MCP only if you've hit the same friction twice (optional)
You leave with At least one custom rule, one workflow-level skill, a configured global layer (~/.claude), and a clear decision framework for when — and whether — to add an MCP.
L4 Live · 75 min · Capstone

Agentic Skills

Consolidation, then opening the system. Three final pieces: working together, automatic checks, and a system that outlives the cohort.

  • Project checkup: audit your CLAUDE.md, add one doc, one rule, one skill — arrive ready
  • Git for operators: branch = safe workspace · commit = save point · PR = the approval gate you know
  • Working together on a shared project — Claude runs git, you make the decisions
  • Hooks: an automatic action triggered by an event — the last mechanism of Claude Code
  • The Agentic Map: a personal master project that holds every building block and grows with you
  • Ship one real change end-to-end: branch → commit → PR → review → merge
Details

Before class

  • Recap: the six building blocks — CLAUDE.md · docs · rules · skills · scripts · MCPs
  • Project checkup: audit CLAUDE.md, add one reference doc, one rule, one skill
  • Git/GitHub for operators: branch · commit · PR — the approval gate made visual
  • GitHub account setup and git initialization — guided, step by step
  • Connect one MCP and take one real action tied to your project

In class

  • Git/GitHub: the shared-project workflow — one visual mental model, three honest acts
  • Live demos: commit/branch/merge loop + a PR review where Claude summarizes the diff
  • Workflow skill: take one process of yours that has steps — Claude writes the skill live
  • Rules that become code: a deterministic script check run from inside a skill
  • Hooks: an automatic action triggered by an event — the last inner mechanism
  • The Agentic Map: holds every building block, grows with every project after the cohort

After class · Gift artifacts

  • Agentic Map starter document — pre-populated with the course's building blocks
  • Setup prompt: paste into Claude Code, the map project builds itself
  • GitHub homework: the full shared-project routine on your own project
You leave with A visual mental model of Git collaboration, a beginner's understanding of hooks, and a pre-populated Agentic Map ready for Claude Code to build into your personal master project.
After lesson 4

Gift artifacts · Delivered post-session · Async

The Agentic Map — your system beyond the cohort

A personal master project delivered at the end of the cohort. Not a summary — a working Claude Code project that stores every building block from all four lessons. Delivered as a pre-populated starter document and a ready-to-paste setup prompt: open Claude Code, paste the prompt, the map builds itself. It grows with every project, every retrospective, every new lesson learned.

  • Pre-populated with every building block from the course
  • Each session retrospective feeds back in — it compounds by design
  • Before any new project: ask the map what to keep in mind
  • Official Claude Code docs woven in, in your language
  • A personal guide that knows exactly how you work
  • No blank-page start — ever again
What participants graduate with
One shipped feature Built, deployed, and verified against three defined success criteria on a real project.
A working CLAUDE.md Context, constraints, and conventions — the file that makes Claude better at their specific project.
At least one custom skill Built for a workflow they already did manually — runs with a single slash command.
A compounding log At least two real entries: what happened, why, what changes next time.
The mental models to keep building Tier classification, define-done, the 3-rep heuristic — frameworks that outlive the cohort.
A personal Agentic Map A master project that holds everything built during the cohort — and grows with every project after.
Program format

Duration

4 weeks

Live sessions

4 × 75 minutes

Time / week

2 hours

Cohort size

Minimum 5 participants

Level

No code required

Tools

Claude Code or Codex

Follow-up

Session after a month

Q&A response

1 business day