Claude Code: Workflows, Debugging & Safety

Claude Code can inspect a repository, edit files, run commands, and keep working until it believes the task is finished. That loop is useful only when the task has a clear boundary and a check that can prove the result. A vague request paired with broad permissions gives the agent room to solve the wrong problem at speed.

A reliable daily loop moves from scoping through verification, with permission modes, checkpoints, and hard boundaries limiting damage when a session goes off course.

I use Claude Code as the control room for agent work, and the biggest improvement came from enforcing repeated boundaries with hooks instead of explaining the same rule again.

Start with a Verifiable Task

The main Claude Code guide covers installation before this scoped workflow begins.

Give Claude one outcome, the scope it may touch, and the check it must run. "Fix login" gives it too many paths. A better request names the symptom, likely code area, constraint, and proof:

The session expires after token refresh in src/auth/. Reproduce it with a focused test, fix the cause without changing the public session type, run that test, and show the result.

The test matters more than extra prompt polish. Without a pass-or-fail signal, Claude stops when the work looks complete. With one, it can run the check, read the failure, revise the patch, and repeat. Anthropic's best-practices guide puts verification first for this reason.

Choose proof that matches the work being changed:

• A function fix needs focused tests, then the broader suite if shared code moved.
• A build setup edit needs the production build command and its exit code.
• An API task needs a request against a test endpoint with the expected status and body.
• A page layout needs the build plus screenshots at the required phone, tablet, and desktop sizes.

Explore, Plan, Implement, and Verify

Plan mode lets Claude read files and run inspection commands without editing source files. Enter it with Shift+Tab, prefix one prompt with /plan, or start the CLI with claude --permission-mode plan. Use it when you do not yet know which files or data paths the task crosses.

1. Explore: ask Claude to trace the current path and name the files involved.
2. Plan: ask for the smallest patch, expected risks, and verification commands.
3. Implement: approve the plan in the permission mode that fits the task.
4. Verify: have Claude run the agreed checks and show their output.

Read the plan as a scope contract. A plan that says "refactor the auth layer" when you asked for one refresh bug needs another pass.

Press Ctrl+G to open the proposed plan in an editor, or give feedback and keep planning. Skip this overhead for a typo, a single log line, or another edit whose diff is obvious before you begin.

Keep each work slice small enough to review. A request that mixes a bug fix, a settings redesign, and a loading state has three success tests and three ways to fail. Split the request before Claude starts editing. Each slice gets its own diff, proof, and commit, which makes review and rollback much less costly.

Debug with Evidence

Give Claude the full error and keep your first guess separate. Paste the stack trace, name the command that produced it, and mention whether it fails every time. Use @ references for the nearest files so Claude can see imports and call sites instead of an isolated line.

Ask for a reproduction before a fix when the bug is not obvious. A failing test pins down the symptom and prevents a patch that only hides the error.

For state bugs, ask Claude to trace where the bad state begins and list each handoff. For a build error, ask it to read the first root error rather than suppressing every later message.

Stop the loop if Claude proposes the same idea twice. Check the base facts yourself: the database is running, the required shell variables exist, the failing request reaches the server, and the branch contains the code you think it does. Then start a cleaner prompt with the new evidence. More turns do not rescue a false premise.

Manage Session Context

A session holds the conversation, file contents, command output, CLAUDE.md, auto memory, loaded skills, and system instructions. That shared context fills while Claude investigates the repository. Run /context to see where the space went instead of guessing.

Run /clear whenever you switch to an unrelated task. Use /compact focus on the auth changes when you must keep the session but want a shorter history.

Claude also compacts on its own near the limit, first clearing old tool output and then summarizing the conversation. Early detail can be lost, so persistent project rules belong in CLAUDE.md rather than a message sent hours ago.

A clean restart is often cheaper than correcting a session filled with rejected plans. Write down the chosen approach, current file state, and next check, then start a fresh session. Use a subagent for broad investigation when you want its file reads kept out of the main context.

Use Permission Modes Deliberately

Mode	What Claude Can Do	Best Fit
Manual	Asks before edits and commands	New repo or sensitive task
Accept Edits	Edits files without each prompt	Scoped refactor with diff review
Plan	Inspects and proposes, no source edits	Research and scope agreement
Auto	Uses background safety checks	Trusted direction with fewer prompts

You can cycle through these modes with Shift+Tab. The permission-mode guide also documents Bypass Permissions mode. That mode removes the normal approval layer and should not be the default on a personal machine.

Do not solve approval fatigue by allowing every shell command. Add narrow allow rules for commands whose effect you know, such as a focused test or git status. Keep deploy, database, account, secret, and destructive commands behind a prompt even when file edits are accepted.

Pair Permissions with Hard Boundaries

Permission settings decide when Claude must ask you first. They are not the same as an operating-system sandbox. If a process has broad file and network reach, one approved command may still do more than you expected. Use /sandbox or an isolated runtime when unattended work needs wider freedom.

Limit every credential to the exact task at hand. A test deployment should not inherit production database keys. A code-reading job does not need write access to a Git host. Narrow file roots and network domains reduce the cost of a mistaken command or hostile text pulled from a webpage, issue, or dependency.

Rules written in CLAUDE.md remain advisory model instructions. They tell the model how the project works, but the model can miss a vague or buried line. Use a PreToolUse hook for a rule that must block an action, such as writes to generated files. The MCP and hooks guide shows the blocking pattern.

Recover with Checkpoints and Git

Claude Code snapshots a file before it edits that file. Press Escape twice or run /rewind to open the checkpoint menu, then restore the conversation, the code, or both. This is quick when the last prompt sent the patch in the wrong direction.

Checkpoints cover file edits. Emails, payments, database updates, and deployments sit outside that recovery boundary, so those commands need tighter permissions and purpose-built rollback steps.

Begin each task by checking the current Git status with git status. Commit or set aside your own work before handing the repo to an agent.

After implementation, inspect git diff --stat, read the full diff, and run the checks yourself when the risk calls for an independent run. A checkpoint helps inside the session; Git records the project history you can return to later.

Know When to Stop the Agent

• Stop when the same failed fix comes back after you rejected it.
• Stop when the proposed scope spreads beyond the files tied to the request.
• Stop when a command touches production, billing, accounts, or secrets without an agreed step.
• Stop when a visual task has no rendered check or a behavior task has only a screenshot.
• Stop when you cannot explain the diff well enough to review it.

Some jobs fit another surface better. A tiny inline edit may be faster in an editor. A layout needs a rendered browser with interaction evidence. A new hosted prototype may be easier in a tool that supplies its own runtime. Hand the agent work that benefits from repository search, command execution, and repeatable checks.

FAQ

When should I use Plan mode?

Use Plan mode when the task spans several files, the route through the code is unclear, or you need to agree on scope before edits begin. Skip it for a tiny fix whose diff you can describe in one sentence. Plan mode can read and inspect, but it does not edit source files.

What proof should I ask Claude Code to produce?

Ask for the smallest check that proves the requested result: a focused test, a production build, a type check, a screenshot, or a response from a test endpoint. Have Claude show the command and outcome. A green build does not prove a visual task, and a screenshot does not prove hidden behavior.

Does a checkpoint replace Git?

No. A Claude Code checkpoint can restore file contents from an earlier prompt, which is useful during one session. It cannot undo a database write, deployment, API call, or other remote side effect. Git gives you a durable project history, so begin from a clean status and review the diff before committing.

Is Bypass Permissions mode safe for local work?

It removes the normal approval boundary, so it is a poor default for a personal machine. Use Manual, Plan, Accept Edits, or Auto mode based on the task, then allow only commands you trust. If unattended work needs broader access, put it inside an isolated runtime with narrow files, credentials, and network reach.

The Boundary That Matters

A sound Claude Code workflow is small enough to review and strict enough to prove. Scope one outcome, plan when the path is unclear, require a matching check, and grant only the access that step needs.

Keep checkpoints for quick recovery and Git for durable rollback. When the evidence or scope stops making sense, stop the agent and restart from facts.

Updated July 2026 with facts checked against official Anthropic sources on July 28, 2026.