The Agentic Loop

A code-completion tool predicts your next few characters. Claude Code does something fundamentally different: when you give it a task, it runs a loop. It works through three phases — gather context, take action, and verify results — using tools at every step, and it repeats the cycle, course-correcting from what it learned, until the task is done.

The official docs describe it cleanly:

"When you give Claude a task, it works through three phases: gather context, take action, and verify results. These phases blend together. Claude uses tools throughout, whether searching files to understand your code, editing to make changes, or running tests to check its work."

The word that matters is blend. These aren't rigid, sequential steps with hard borders. Claude might gather a little context, take an action, see the result, gather more context, and act again — chaining dozens of tool calls together. You are part of the loop too: you can interrupt at any point (press Esc) to redirect, and Claude course-corrects.

Keep this single picture in your head for the rest of the course. Almost every feature you'll learn — plan mode, CLAUDE.md, subagents, hooks, context management — is a way to shape one or more phases of this loop.

Each phase is a different kind of work Claude does — and each is powered by a different set of tools.

Here's the loop in motion. When you say "fix the failing tests," Claude might:

1. Run the test suite to see what's failing      ← gather context
2. Read the error output                          ← gather context
3. Search for the relevant source files           ← gather context
4. Read those files to understand the code        ← gather context
5. Edit the files to fix the issue                ← take action
6. Run the tests again to verify                  ← verify results

Each tool use returns information that feeds back into the loop and informs the next decision. Step 6 might pass — done — or it might surface a new failure, sending Claude back to gather more context. That feedback is the engine.

Claude doesn't run all three phases every time. It decides what each task requires, based on what it learned from the previous step. The mix of phases adapts to the work:

This adaptivity is why you can't reduce Claude Code to a script. It chains together however many actions a task needs and course-corrects along the way. A question may only gather context. A quick rename may skip serious verification. A refactor leans hard on verification because there's more that can break.

Understanding this helps you set expectations: if you ask a pure question, don't be surprised when Claude never edits a file. If you ask for a risky change, expect — and want — it to spend time verifying.

Tools are what make Claude Code agentic. Without tools, a model can only produce text. With tools, it can act — and each tool use returns information that feeds the next decision. Claude Code's built-in tools fall into five categories, and each one naturally serves a phase of the loop:

A few mappings are worth pausing on:

• File operations span two phases. Reading a file gathers context; editing it takes action. Same category, different intent.
• Execution is the workhorse of verification. Running tests is how Claude checks its own work — which is exactly why giving it something runnable matters so much (next section).
• Beyond these five, Claude also has tools for spawning subagents and asking you questions — orchestration moves you'll meet later.

Here's the part that surprises people. The intelligence comes from the model, but the agency comes from the harness around it.

The docs name this directly:

"The agentic loop is powered by two components: models that reason and tools that act. Claude Code serves as the agentic harness around Claude: it provides the tools, context management, and execution environment that turn a language model into a capable coding agent."

Think about what the harness actually is. The vast majority of Claude Code is plain, deterministic software engineering: the code that finds files, runs your tests, snapshots files for checkpoints, manages permissions, packs and compacts the context window, parses tool output, and feeds it back. By Anthropic's own accounting, roughly 98.4% of Claude Code is deterministic infrastructure — ordinary, predictable code — and only about 1.6% is the AI decision logic where the model chooses what to do next.

That tiny slice of model reasoning is decisive, but it's only useful because the deterministic 98.4% gives it real tools, real results to react to, and a loop to run in. A model with no tools is a chatbot. A model wrapped in a loop that gathers context, acts, and verifies is an agent.

This reframes how to get good results: you improve outcomes less by "asking the model harder" and more by shaping the loop — giving it the right context, the right tools, and a clear way to verify success.

The loop quietly raises two questions that shape every workflow you'll build. The rest of the course answers them.

1. Verification matters because Claude stops when work looks done. The verify phase only works if there's a signal to check against. Give Claude a failing test, a build command, a screenshot of the target UI, or an exact expected output, and it will run the verify phase against that signal and iterate until it passes. Give it nothing to check against, and you become the verification loop — eyeballing every change by hand. The single highest-leverage habit in Claude Code is handing it something it can verify against.

Implement validateEmail. Test cases:
'user@example.com' → true, 'invalid' → false, 'user@.com' → false.
Run the tests after.

That last line — run the tests after — closes the loop for Claude. Module 2 is all about this.

2. Context is finite, and every loop iteration consumes it. Each file read, each command output, each test run pours into a context window that holds the conversation, file contents, CLAUDE.md, memory, and system instructions. As the loop runs, context fills up. Performance is about quality of context, not just quantity — raw logs and repeated reads compete with the signal that matters. Managing what's in the window (with /context, /clear, /compact, and subagents) becomes a core skill. Module 3 is all about this.

Hold onto the loop as your map. Everything ahead is a technique for running it better.