Claude Code Unsupervised: Hours of Work You Can Trust

What's inside

1. Level 1: Ground Rules: An Independent Course on a Moving ToolFree
   States that this course is independent of Anthropic and teaches the habit of checking every feature, name, limit and plan against the current Claude Code documentation and your installed version before relying on it.
2. Level 2: What Makes a Task Safe to Hand Over for HoursFree
   Learn to judge whether a piece of work suits a long unsupervised run by looking for a verifiable end state, a bounded blast radius and the ways long runs typically fail.
3. Level 3: Plan Mode: Explore Before Any Edit
   Use plan mode to have Claude read the codebase and propose an approach without changing files, then review that plan as the cheapest point to correct course.
4. Level 4: The Written Brief: Scope, Constraints, Acceptance
   Turn an accepted plan into a brief file in the repository that states scope, non-goals, constraints and acceptance checks, so the task survives compaction, resumption and handover.
5. Level 5: /goal: A Completion Condition That Keeps Claude Working
   Set a /goal condition so Claude keeps taking turns until a separate evaluator model judges the condition met or impossible, and write conditions that evaluator can actually judge.
6. Level 6: A Lean CLAUDE.md That Earns Its Tokens
   Trim project memory to the short set of instructions Claude cannot infer from the code, because every line is loaded into every session and bloat dilutes the rules that matter.
7. Level 7: Reading the Context Window in a Long Session
   Understand what fills the context window over hours, how to inspect it, and what automatic compaction keeps and drops, so you can predict when a session will start forgetting.
8. Level 8: Directed Compaction and When to Clear Instead
   Steer what a summary preserves by compacting deliberately with instructions at a natural milestone, and choose between compacting, summarising part of the conversation and clearing outright.
9. Level 9: Checkpoints and Rewind, and What They Miss
   Use automatic checkpoints and the rewind menu to restore code, conversation or both, and know the gaps that mean git commits remain your real safety net.
10. Level 10: Naming, Resuming and Branching Sessions
    Return to a long-running piece of work days later and fork it to try an alternative, knowing which state a resumed or branched session carries over and which you must supply again.
11. Level 11: The Permission Modes Map
    Compare the permission modes by what each lets run without asking, how a session's starting mode is decided, and which modes suit unattended work.
12. Level 12: Auto Mode: A Classifier in Place of Your Approval
    Understand how auto mode has a second model review actions instead of you, what it tends to block, and how to tell it which repositories and services your organisation trusts.
13. Level 13: Allow, Ask and Deny Rules for Least Privilege
    Write permission rules that pre-approve exactly what a task needs and deny what it must never touch, with correct matching syntax and precedence across settings scopes.
14. Level 14: The Sandboxed Bash Tool: An OS-Enforced Boundary
    Turn on the built-in sandbox so the operating system limits which files and hosts shell commands can reach, letting sandboxed commands run without a prompt each time.
15. Level 15: Tuning the Sandbox and Knowing Its Edges
    Fit the sandbox to a real project by adjusting writable paths and allowed domains, handling tools that break inside it, and accounting for everything that runs outside it.
16. Level 16: Choosing a Sandbox Environment: Containers and VMs
    Compare whole-environment isolation options such as dev containers, Docker and virtual machines with the built-in sandbox, and match the isolation level to your threat model.
17. Level 17: Hook Fundamentals: Events, Handlers and Exit Codes
    Learn how hooks run your own code at fixed points in Claude's lifecycle, the handler types available, and how exit codes and JSON output turn a hook into a deterministic control.
18. Level 18: PreToolUse Hooks That Block or Rewrite
    Write a PreToolUse hook that inspects a tool call before it runs and either denies it with a reason Claude can act on or rewrites its input into a safe form.
19. Level 19: The Stop Hook as a Completion Gate
    Use a Stop hook to refuse to let Claude finish until a deterministic check passes, and design it so it cannot loop forever or be satisfied by a mere claim.
20. Level 20: Keeping Secrets Out of an Unattended Session
    Stop credentials reaching the model, the transcript or the network during unsupervised work by controlling what is readable, what is in the environment and how much each credential can do.
21. Level 21: Secrets: Keep Credentials Out of Claude's Reach
    Closes the guardrails phase by treating every secret as something an unattended session should never be able to read, print or send, and wiring that into rules, sandbox limits and short-lived credentials.
22. Level 22: Git Worktrees: One Checkout per Session
    Opens the parallel phase with the isolation primitive everything else depends on: a separate git worktree per session so two Claudes never edit the same files.
23. Level 23: Parallel Sessions by Hand: Slicing the Work
    Teaches how to cut a job into slices that can run side by side in separate sessions, and how to bring the branches back together.
24. Level 24: Background Agents and Agent View
    Moves sessions off your terminal with background agents and the agent view dashboard, which the current documentation labels a research preview.
25. Level 25: Subagents: Delegating to Protect Context
    Explains subagents as workers with their own context window, so a long session can hand off noisy exploration and get back only a summary.
26. Level 26: Custom Subagents: Least Privilege per Worker
    Builds reusable subagent definitions whose tools, model, permission mode and isolation are fixed in a file rather than left to the moment.
27. Level 27: Who Holds the Plan: Subagents, Teams, Workflows
    Compares the orchestration options by one question, who decides what runs next and where intermediate results live, so the learner picks the right one before spending tokens.
28. Level 28: Dynamic Workflows: Your First Fan-Out
    Runs a first dynamic workflow, in which Claude writes a script that a background runtime uses to orchestrate many subagents, and learns to read the plan before approving it.
29. Level 29: Workflows in Practice: Save, Resume, Bound the Cost
    Turns a one-off workflow into a repeatable, budgeted tool by saving and parameterising it, resuming after failure and using the runtime's limits and size guideline.
30. Level 30: Verification Skills: Checks Every Worker Runs
    Packages the project's definition of done as a skill, so every session, subagent and workflow agent proves its work the same way instead of just saying it is finished.
31. Level 31: When Parallelism Loses: The Coordination Cost
    Closes the phase with the honest accounting: merge conflicts, duplicated work, usage that scales with session count, and a human review queue that does not scale at all.
32. Level 32: Cloud Routines: Anatomy and Blast Radius
    Introduces routines (research preview at the time of writing) as saved cloud configurations of prompt, repositories, environment and connectors that run with no permission prompts and act as you.
33. Level 33: Schedule Triggers: Recurring and One-Off Runs
    Puts a routine on a clock and writes the self-contained prompt an unattended run needs, with the current limits in view.
34. Level 34: API and GitHub Triggers: Event-Driven Routines
    Fires routines from other systems, via an HTTP call from an alert or deploy script or a GitHub pull request or release event, while treating whatever arrives as untrusted input.
35. Level 35: Desktop Scheduled Tasks: Local Recurring Runs
    Covers scheduled tasks in the desktop app, which run on your own machine with access to local files and tools but only while the app is open and the computer is awake.
36. Level 36: /loop: Polling Inside a Live Session
    Uses /loop and in-session scheduling for short-lived babysitting work such as watching a deploy or a pull request, and learns its session-scoped limits.
37. Level 37: Headless Mode: claude -p Without a Keyboard
    Runs Claude Code non-interactively from a script, with permissions settled up front because nobody is there to answer a prompt.
38. Level 38: Output Formats and Piping: Claude in a Pipeline
    Treats headless Claude as a Unix tool: pipe data in, get text, JSON or a stream out, and chain calls together.
39. Level 39: Routine, Headless or Agent SDK: Choosing the Runner
    Compares the unattended runners on where they execute, what they can reach, who they authenticate as and how much control you get, so each job lands in the right place.
40. Level 40: GitHub Actions: Claude in Your Own CI
    Runs Claude Code in GitHub workflows with the official action, covering mention-driven and prompt-driven modes, who is allowed to trigger a run, and how to cap its permissions and cost.
41. Level 41: Automatic Code Review on Every Pull Request
    Set up automatic review of pull requests with Anthropic's managed Code Review (research preview on Team and Enterprise plans at the time of writing) and the local /code-review command, and tune both so findings are worth reading.
42. Level 42: Layered Security Review
    Stack Claude's security checks (the in-session security-guidance plugin, /security-review, the Claude Security plugin's deep scan, and PR-time review) alongside your existing scanners, knowing what each layer does and does not catch.
43. Level 43: Cloud Sessions and Their Environments
    Run long tasks as cloud sessions on Anthropic-managed or self-hosted infrastructure, and configure the environment (network access, variables, setup script) that decides what the session can reach.
44. Level 44: Teleport: Moving Work Between Cloud and Terminal
    Hand work off between surfaces deliberately, using plan-locally-execute-in-cloud and teleport to pull a cloud session and its branch back to your machine.
45. Level 45: Remote Control and Dispatch: Steering From Your Phone
    Steer a session that runs on your own machine from a browser or the mobile app with Remote Control, and start desktop work from your phone with Dispatch, checking current plan and preview status first.
46. Level 46: Slack and Channels: Events That Start or Reach a Session
    Start work from team conversation with Claude in Slack, and push CI results, alerts and chat messages into an already-running local session with Channels (research preview, not available on third-party providers at the time of writing).
47. Level 47: Chrome for Debugging: Evidence From a Real Browser
    Give Claude a real browser through the Chrome integration so UI work is checked against console output, network behaviour and screenshots rather than assumed correct.
48. Level 48: Verifying a Run: Read the Diff, Run the Tests
    Treat the agent's final summary as a claim, and verify an unsupervised run yourself from the diff against the base branch and from tests you run in a clean checkout.
49. Level 49: The Cold Second Opinion
    Get an independent review from a fresh context that has no stake in the original approach, and demand evidence for every finding and every claim of completion.
50. Level 50: Prompt Injection and Supply-Chain Risk
    Recognise how untrusted content (issues, PR comments, web pages, dependencies, MCP servers, plugins) can steer an unattended agent, and contain the damage with the guardrails built earlier.
51. Level 51: Cost, Model and Effort Choice
    Predict and control what hours of unattended work cost by matching model and effort level to the job and by understanding why long sessions, subagents, loops and cache misses multiply usage.
52. Level 52: Bedrock, Google Cloud and Foundry as Providers
    Run Claude Code through Amazon Bedrock, Google Cloud's Agent Platform (Vertex AI) or Microsoft Foundry, and know which features covered in this course are unavailable there.
53. Level 53: Managed Settings and Policy for Teams
    Enforce the least-privilege setup across an organisation with managed settings that users cannot override, delivered by device management or server-managed settings.
54. Level 54: Analytics and Monitoring Across a Team
    Measure adoption, spend and behaviour of supervised and unsupervised use with the analytics dashboards and OpenTelemetry export, and treat the numbers as estimates rather than invoices.
55. Level 55: Packaging Your Setup as a Plugin
    Bundle the skills, subagents, hooks and MCP configuration built during the course into a versioned plugin, distribute it through a marketplace, and control it centrally.
56. Level 56: Final Challenge: An Unsupervised Run You Can Trust Exam
    A comprehensive review of the whole course: design, guard, run and verify a multi-hour unattended task end to end, and defend every choice.

Access

The first 2 levels are free with a free account. Every level, the podcast edition and the AI tutor come with All Access at £4.99/month or any Creator plan — see pricing.

Start free →