Turn Claude Code into a Senior Engineer with a 9‑Step Loop

1. Explore before you code

Claude Code’s built‑in Explore subagent reads the codebase in read‑only mode inside its own context window, so the model can map files, data flow, and fragile areas without modifying anything.

START WITH EXPLORATION
# "Explore how authentication works across this codebase. Map the files involved, the data flow, and anything that looks fragile. Don't change anything yet."

✓ The agent now understands the code structure before any edit.

2. Use Plan Mode to draft a solution

In plan mode Claude thinks through the implementation without touching files, producing a step‑by‑step plan that you can review, edit, and approve.

PLAN MODE
# "In plan mode: lay out exactly how you'd add rate limiting to the API. List the files you'll touch, the order, and the risks. Wait for my approval before writing code."

✓ No bad plan reaches the codebase.

3. Encode team standards in CLAUDE.md

Write your conventions, commands, and rules once in CLAUDE.md. Every session reads this file, giving the agent the same baseline as the team.

CLAUDE.md // PROJECT ROOT
# Project Standards
## Conventions
- TypeScript strict mode, no `any`
- Functions over classes where possible
- Every new function gets a test
## Commands
- Test: `npm run test`
- Lint: `npm run lint`
- Build: `npm run build`
## Rules
- Never edit files in /generated
- Match existing file style before adding code
- If unsure, ask before building

Instructions are advisory; critical rules are enforced with hooks.

4. Build in small, reviewable chunks

After the plan is approved and standards are loaded, make incremental changes. Small diffs are easier to verify, rollback, and review.

BUILD INSTRUCTION
"Implement step 1 of the approved plan only. Keep the change small and self‑contained. Follow the conventions in CLAUDE.md. Stop after step 1 so I can verify before you continue."

✓ Changes appear as manageable reviews instead of a massive diff.

5. Enforce non‑negotiable rules with hooks

Hooks are deterministic shell commands that run at specific points in Claude Code’s lifecycle, guaranteeing that critical rules cannot be bypassed.

{
  "hooks": {
    "PostToolUse": [{
      "matcher": "Edit|Write",
      "command": "npm run lint && npm run test"
    }]
  }
}

✓ Lint and tests run after every edit; commits are blocked on test failures.

6. Verify every change with tests

Never accept “looks good to me”. Require the agent to write tests for each change, run the full suite, and only proceed when all tests pass.

TEST INSTRUCTION
"Write tests that cover this change, including the edge case where the token is expired. Run the full suite and show me the results. If anything fails, fix it before continuing."

✓ “Done” means tests passed, not just a plausible diff.

7. Launch a review subagent

Start a fresh subagent whose sole job is to critique the diff, catching security issues, missed edge cases, and rule violations.

REVIEW SUBAGENT
"Launch a review subagent. Its job: review the diff I just made as a skeptical senior engineer. Check for security issues, missed edge cases, and anything that violates CLAUDE.md. Report problems, do not fix them yet."

✓ An independent critic spots problems the builder missed.

8. Fix, retest, and re‑review until clean

Iterate: fix the issues, run tests again, and relaunch the review subagent. The loop closes only when the review returns clean.

CLOSE THE LOOP
"Address every issue the reviewer raised. After fixing, re‑run the tests AND launch the review subagent again on the updated diff. Repeat until the review comes back clean. Show me the final review verdict."

✓ Problems are not just acknowledged; they are resolved and verified.

9. Ship with a slash command

Package the entire nine‑step loop into a custom slash command (e.g., /ship) so you can trigger the full senior‑engineer pipeline with a single command.

.claude/commands/ship.md // YOUR WHOLE LOOP, ONE COMMAND
# /ship : run the full senior‑engineer loop
1. Explore the relevant code (Explore subagent)
2. Plan the approach and wait for my approval
3. Build per CLAUDE.md in small pieces
4. Write + run tests (hooks enforce this)
5. Launch a review subagent on the diff
6. Fix issues, re‑test, re‑review until clean
7. Commit with a clear message and open a PR

✓ Running /ship executes the entire disciplined workflow automatically.

The nine‑step loop simply maps the disciplined practices senior engineers already follow—exploration, planning, incremental builds, enforced standards, automated testing, independent review, and repeatable shipping—onto Claude Code’s native capabilities.