How to Use Claude Code: A Checkpoint-Based Workflow for Building With AI
https://hub.october.dev/how-to-use-claude-code
Learn how to use Claude Code with checkpoints for context, terminal actions, visual review, MCP, and multi-agent workflows. Get started.

Learning how to use Claude Code effectively starts with controlled execution, not a giant prompt. Give Claude Code a contained task, establish repository context, review each tool action and diff, then inspect the running result in an editor or browser before expanding the workflow.

Set Up Claude Code Around a Real Build

Start inside a project folder that already has a clear purpose. Confirm the working directory, check the current branch, and choose one contained task such as adding a settings panel, fixing a failing test, or changing one API response. Claude Code runs in the terminal and can work alongside IDEs such as Visual Studio Code and JetBrains tools, so the terminal becomes the execution surface rather than the entire review environment. Claude Code product documentation

The wrong opening prompt is “Build my product.” It gives the agent too much surface area and leaves the builder with no reliable checkpoint. A stronger prompt states:
• What the code does now
• What behavior should change
• What must remain untouched
• How success will be tested

For example:

> The dashboard currently shows all invoices in one list. Group them by customer. Keep the export button, URL structure, and existing filters unchanged. First inspect the relevant files and propose a plan. Do not edit until the plan is approved.

That prompt gives Claude Code a bounded target and a reviewable next move. AI Master makes the same case in Ultimate Claude Code Tutorial: How to Use Claude Code for Beginners in 2026, where narrow prompts and explicit constraints reduce unintended edits.

Your first receipt should be visible before further work begins: the correct project folder, the initial prompt, and either a proposed plan or a small file change you can inspect.

Establish Context Before Asking for Changes

Ask Claude Code to inspect the repository before asking it to modify anything. A useful first request is:

> Inspect this repository. Identify the application entry point, relevant feature files, test commands, and configuration files. Summarize the architecture, list the files relevant to this task, and propose an implementation plan. Do not edit yet.

This creates a repository map. It also exposes wrong assumptions early, while the cost of correction is low. If the agent identifies the wrong framework, test command, or feature boundary, correct the context before approving a plan.

For durable instructions, add a project-level `CLAUDE.md` file at the repository root. It can record the language, framework, naming conventions, test commands, review criteria, and files that must not change. Anthropic’s documentation states that `CLAUDE.md` files load at session start, while `CLAUDE.local.md` is intended for local, git-ignored preferences. Auto memory is separate: Claude Code stores project memory in `MEMORY.md` and loads the first 200 lines or 25 KB at session start. Claude Code memory documentation

A good shared file might say:

```md
Project instructions
• Use TypeScript and existing ESLint rules.
• Run `npm test` after changes.
• Keep API response shapes backward compatible.
• Do not edit generated files in /dist.
• Summarize changed files and test results before finishing.
```

The 4 MiB limit for `CLAUDE.md` files is a useful boundary: keep instructions focused instead of turning the file into a second documentation system. The receipt is a checked repository map, an approved plan, and a `CLAUDE.md` draft that reflects how the project actually works.

How Do You Use the Terminal in Claude Code?

Use the terminal as a controlled tool loop:
State one concrete objective.
Let Claude Code inspect files or run the relevant command.
Review the proposed action.
Approve or reject it deliberately.
Inspect the output, changed-file list, and diff.

Terminal actions should produce evidence. Searching identifies the code path. Tests reveal whether behavior changed. A local server shows whether the application starts. A reproduction command confirms whether a bug still exists. The point is to make each command answer a specific question.

For a failing form, the sequence might be:

```text
Find the validation logic for the signup form.
Run the existing form tests.
Reproduce the current failure with the narrowest relevant test command.
Propose a fix without changing the API contract.
```

Generated changes can sprawl when the request has no boundary. “Rewrite the authentication flow” invites unnecessary edits. “Fix the redirect after successful password reset. Keep token creation, error messages, and route names unchanged” gives Claude Code a smaller search space. AI code generation and ownership risks is useful background for deciding where human review belongs.

The receipt for this step is concrete: command output, changed-file list, and diff. If the diff touches unrelated modules, reject the action and narrow the prompt. The good workflow is to let Claude Code run tests, propose edits, and wait for approval. The bad workflow is to allow automatic changes across a working tree without an isolated branch or review checkpoint.

How Can You Use Visual Studio Code?

Use Claude Code for repository reasoning and terminal actions, then use Visual Studio Code to inspect the result. Open the project folder as a workspace, review the changed files, read the diff, inspect diagnostics, and run the application locally. Visual Studio Code documentation

This matters because a terminal transcript shows activity, while an editor shows state. The transcript may tell you that Claude Code edited three files. Visual Studio Code lets you see whether those files contain the intended changes, whether diagnostics appeared elsewhere, and whether the feature behaves correctly in the running application.

Cursor follows a similar editor-centered pattern and advertises parallel autonomous agents through its own agent tools. Cursor agent features The decision criterion is simple: choose the environment that makes the changed files, runtime output, and approval boundary easiest to inspect. Claude Code remains useful as the terminal-integrated agent even when Visual Studio Code or Cursor is the visual review surface.

Use this checkpoint before merging:
• Diff matches the requested scope.
• Diagnostics are understood.
• Relevant tests pass.
• The application starts locally.
• The visible behavior matches the requested change.

The receipt is an approved diff plus a visible, tested result. A successful command is evidence, but it is not the whole state of the system.

Manage Context, MCP, and Parallel Work Deliberately

Context management determines how reliable a long Claude Code session remains. Files read, prompts sent, commands run, and tool results all consume the context window. Claude’s Context Management in Claude Code explains why a feature-focused session needs deliberate cleanup as the conversation grows.

Use `/compact` when the same feature still needs work and the useful context can be summarized. Compaction can lose details, so check the resulting summary before continuing. Use `/clear` when the current feature is complete and the next task has a different goal. Start a fresh session when repeated fixes produce guesses, contradictory plans, or unnecessary edits. A new session is often more reliable than adding another correction to a noisy conversation.

MCP connects Claude Code to external tools and data sources. Servers can be configured at project, user, or managed scope, with timeout controls available per server or globally. MCP tasks are version-sensitive and documented as public beta functionality, with the current documentation specifying Claude Code v2.1.304 or later for those tasks. MCP documentation for Claude Code

Enable only the MCP services relevant to the task. Before approving an unexpected external action, use this stop condition: if a tool requests credentials or side effects you did not expect, pause and require manual authentication and an explicit `/mcp login` before resuming.

Your receipt is a short context summary, an enabled-tool list, and a decision about whether the work stays with one agent or moves to an isolated subagent.

Add a Runtime Checkpoint Before You Scale the Workflow

A reliable Claude Code workflow can be organized into four checkpoints:

| Checkpoint | Question to answer | Evidence |
|---|---|---|
| Context | What does the agent know about the repository and task? | Repository map, `CLAUDE.md`, session summary |
| Action | What can the agent change or call? | Proposed command, tool scope, worktree |
| Review | What did the builder verify? | Diff, diagnostics, tests, runtime output |
| Iteration | What happens next? | Approved follow-up, `/compact`, `/clear`, or handoff |

Apply the model differently depending on the work:
• Feature: inspect the relevant files, plan the change, review the diff, then test the visible behavior.
• Bug fix: reproduce the error first, identify the smallest code path, apply the fix, and rerun the reproduction.
• Multi-step workflow: separate planning, implementation, testing, and approval so each handoff has a visible artifact.

This is where visual runtime inspection becomes important. A linear terminal transcript can show that agents acted, but it makes parallel state, handoffs, and waiting tasks harder to understand. October is a desktop IDE for visual AI agent orchestration and runtime work. Its spatial canvas and October Bus are designed for discovery, scoped context exchange, visual inspection, and interruptibility across agent nodes. October documentation

October fits when a solo founder or small team needs to coordinate multiple agents and intervene intentionally. Cursor focuses on an AI coding environment. Superset reports support for multiple coding agents, isolated Git worktrees, external IDEs, and a free tier. Superset orchestration workspace AO Agents describes a desktop environment for supervising coding agents across isolated workspaces. AO Agents documentation Langflow targets low-code construction of agents and MCP servers. Langflow AI builder

The choice depends on the bottleneck:

| Workflow need | Best fit to evaluate | Decision rule |
|---|---|---|
| One repository, one primary agent | Claude Code with VS Code | Keep the loop terminal-first and review the diff visually |
| Multiple coding agents with isolated worktrees | Superset or AO Agents | Choose this path when parallel branches are the main problem |
| Visual, spatial agent coordination | October | Choose it when state, handoffs, and interruption need to be visible |
| Low-code agent and MCP composition | Langflow | Choose it when the workflow is defined through connected components |
| Editor-centered AI coding | Cursor | Choose it when coding and agent interaction should live in one IDE |

Before scaling, document the workflow graph, show the agent handoff, and verify the output. That gives the builder a runtime checkpoint instead of relying on activity in a transcript.

Key Takeaways
• Start Claude Code with a contained task, explicit constraints, and a reviewable plan.
• Put shared project rules in `CLAUDE.md`, then manage `/compact`, `/clear`, and new sessions according to task boundaries.
• Treat terminal commands, MCP calls, diffs, tests, and runtime behavior as separate approval checkpoints.
• Add a visual runtime layer when multiple agents, handoffs, or long-running actions become difficult to inspect linearly.

When terminal execution starts turning into a coordination problem, October gives builders a more visual way to arrange agents, inspect runtime state, and pause before approval. Teams that want to test that checkpoint-based approach can Get Started.

Frequently Asked Questions

How to use terminal in Claude code?

Open the project folder, confirm the working directory, and give Claude Code one bounded objective. Let it inspect files or run a relevant command, review the proposed action, then check the command output, changed-file list, diff, and tests before approving the next step.

How can I use Visual Studio Code?

Open the repository as a Visual Studio Code workspace and use it to inspect diffs, diagnostics, files, and the running application. Claude Code can remain the reasoning and terminal agent while Visual Studio Code provides the visual review checkpoint.

How do I use MCP in Claude Code?

Connect only the MCP servers relevant to the current project, review their tool scope, and set appropriate timeouts. Pause if a tool requests unexpected credentials or external side effects, then authenticate manually before continuing. MCP task availability depends on the Claude Code version and current feature status.

Are there ways to use the Claude code for free?

Access and pricing depend on the current Claude Code offering and account setup, so check the current subscription and product documentation before planning a workflow. A free or limited setup still benefits from the same method: narrow tasks, explicit context, manual approval, visible diffs, and runtime checks.

Continue this guide
• What Is Claude Code? A Builder's Guide to Terminal Agents and Visual AI Workflows

Instagram examples:

https://www.instagram.com/reel/DZ74EVugOiE/