A long session drifts unless you shape it. Scope the work with plan mode, direct compaction so the summary keeps what matters, use the rewind menu to course-correct, set a goal when you can describe done better than the steps, and run parallel work in worktrees.

Video: Steering Long Sessions

Steering Long Sessions

Scope it before you run it

Options

Rewind menu

Goal

Worktrees

Rewind, goal, or worktree?

Steer the Work

Claude follows a lean set of instructions far more reliably than a long one. Write a CLAUDE.md that survives contact with a real project, package repeated procedures as skills, match the permission mode to the job, and move the rules Claude must never skip into hooks.

Video: A CLAUDE.md That Follows

A CLAUDE.md That Follows

Put the file on a diet

Video: Verification Skills

Verification Skills

The skill worth building first

Which surface owns the rule?

Video: Permission Modes

Permission Modes

Match the mode to the job

Video: Hooks

Hooks

Make the rule unskippable

Redact instead of block

Configure Claude

Once you trust Claude with a task, stop doing it by hand. Schedule prompts as routines on Anthropic's infrastructure, drop to headless mode when the job needs your own pipeline, and put Claude to work on pull requests with managed code review and the GitHub action.

Video: Routines and Headless

Routines and Headless

Routine, headless, or SDK?

Video: GitHub Actions and Code Review

GitHub Actions and Code Review

Wire up the action

Automate Repeat Work

A run nobody watched needs a real check, not a tidy summary. Read the diff yourself, gate the turn on tests with a hook, get a cold second opinion on anything that matters, then package the setup you trust as a plugin your whole team can install.

Video: Trust It: Verifying Unsupervised Runs

Trust It: Verifying Unsupervised Runs

Gate the turn, don't take its word

A cold second opinion

Video: Plugins

Plugins

Package what you built

Verify and Share

Claude Code can finish a quick task in a single prompt. The hard part is trusting it with hours of work you didn't watch, and that gap is what this course closes. You'll scope long sessions with plan mode, steer them with directed compaction and the rewind menu, and run parallel work in worktrees. You'll configure Claude so it follows you: a lean CLAUDE.md, repeated procedures packaged as skills, the right permission mode for each job, and hooks that enforce the rules Claude must not be able to skip. Then you'll hand work off entirely with routines, headless mode, and the GitHub action, and verify what came back by reading the diff, gating the turn on real test results, and getting a cold second opinion. By the end you can point Claude at hours of work, walk away, and check the result with confidence.

<h2>Trust Claude Code With Work You Didn't Watch</h2>
Claude Code can finish a quick task in a single prompt. The hard part is handing it hours
of work, walking away, and trusting what you find when you get back. That gap is what this
course closes. You'll work inside a real project the whole way through, and because
DataCamp provides a ready-to-use environment, you'll run actual Claude Code sessions from
the very first exercise, with no installation or API key required. This course picks up
where an introduction leaves off, so you should already be comfortable running Claude Code
and pointing it at a project.
<br><br>
<h2>Steer a Long Session Before It Drifts</h2>
Long runs fail quietly, and the fixes are all things you do rather than things you hope
for. You'll scope multi-file work with plan mode, reading the plan and pushing back on it
before a single file changes. You'll direct compaction so the summary keeps the thread you
name instead of whatever Claude picks. You'll use the rewind menu to undo a wrong turn or
compress a long setup phase, set a goal when you can describe "done" more precisely than
the steps, and run parallel sessions in worktrees without them clobbering each other.
<br><br>
<h2>Configure Claude So It Actually Follows</h2>
Claude follows a lean set of instructions far more reliably than a long one. You'll cut a
bloated CLAUDE.md down to rules specific enough to check, and learn why imports organize a
file without shrinking what loads. You'll package repeated procedures as skills, where the
description is the trigger that makes one fire on its own. You'll match the permission mode
to the job, from hands-on editing to unattended pipelines. And you'll move the rules Claude
must never skip into hooks — code that runs, refusing a push to main outright, or rewriting
a command to strip a live API key while letting the work continue.
<br><br>
<h2>Hand the Work Off Entirely</h2>
Once you trust Claude with a task, stop doing it by hand. You'll schedule prompts as
routines that run on Anthropic's infrastructure with nothing for you to host, and learn the
guardrails that make an autonomous run safe to leave alone. You'll drop to headless mode
when a job needs your own pipeline, shaping output to a JSON schema so the next script can
read it. You'll see where the Agent SDK fits when the work belongs inside your own
application, and put Claude on pull requests with managed Code Review and the GitHub
action.
<br><br>
<h2>Verify What Came Back, Then Share It</h2>
A run nobody watched needs a real check, not a tidy summary. You'll read the diff rather
than the write-up, and see why a clean summary can sit on top of a change nobody asked for.
You'll gate the end of a turn on a real type check with a Stop hook, so Claude cannot finish
on a broken build. You'll get a cold second opinion from a session with no memory of how the
code was written. Finally you'll package the setup you trust — skill, hooks and all — as a
plugin your whole team installs in one step.
<br><br>
By the end you'll be able to point Claude Code at hours of work, walk away, and check the
result with confidence.

Claude Code 101

Trust Claude Code with work you don't watch: steer long sessions, enforce rules with hooks, hand jobs off with routines and GitHub, and verify what comes back.

Claude Code in Action

Claude drifted three prompts ago, and the files are now in a worse state than when it started.

A long setup phase is eating context, but the implementation turns after it need to stay intact.

You can describe what finished looks like, tests passing and a clean type check, more precisely than you can list the steps.

Claude keeps calling the task finished while the checks it ran are still failing.

Two Claude sessions need to work on the same repository at once without overwriting each other's files.

Every parallel session needs its own copy of a git-ignored environment file to run.

Rewind, goal, or worktree?

Claude Code in Action

动手互动练习