Claude Code Lesson 2: The Research -> Strategy -> Execution Cycle

Thinking Like an Agent

The biggest mistake senior engineers make when adopting Claude Code is treating it like a "Faster Copilot." They jump straight into "Execution." They say: "Fix the bug in the Auth service."

The result: Claude starts blindly editing lines, potentially breaking hidden dependencies it didn't see. By the time it realizes the error, your file is a mess and your context is saturated.

To use Claude Code at a Staff+ level, you must enforce a Three-Phase Agentic Workflow. In high-end sessions, you will actually see the model narrate these phases to you.

Phase 1: Research (Mapping the Territory)

Before a single line of code is changed, the agent must build an internal graph of the project's logic. This is the "Mapping" phase.

The Mental Model: If you were a human joining a new team at Netflix, you wouldn't commit code on your first hour. You'd read the documentation, search the codebase for symbols, and understand the "Why" behind the architecture.

Staff-Tier Research Prompt:

"Research the current implementation of the PaymentGateway. Specifically, find all references to stripe.charges.create. I want to know if we are still using the deprecated Charges API or the new PaymentIntents API. Check for existing test coverage for payment failures. Do not modify any files."

Tools used by the Agent:

grep_search: To find API references across 100+ files.
ls -R: To see the directory structure of the payments module.
read_file: To understand the interfaces and current error handling.

Phase 2: Strategy (The Decision Gate)

Once the research is complete, the agent (or you) should propose a formal strategy. This is where you Course Correct.

The Strategy Document: Claude will often summarize its findings and present a plan: *"I found 3 files using the deprecated API. My plan is to:

Create a new StripeAdapter implementing the v3 SDK.
Update the CheckoutService to use the new adapter.
Run the existing payment.test.ts to ensure no regressions. Should I proceed with this plan?"*

Why this is critical:

This is your "Guardrail." It prevents the AI from taking an architectural direction you disagree with (e.g., introducing a new dependency when you want to use native fetch, or using a library that is being phased out).

Phase 3: Execution (The Act -> Validate Loop)

This is where the autonomous "Agent" behavior truly shines. The agent enters a loop of Action and Validation.

The Loop Mechanics:

Act: Apply a surgical change using the replace tool.
Validate: Immediately run a shell command (e.g., npm run test or go test).
Diagnose: If the test fails, the agent doesn't stop. It reads the stack trace, identifies the line of code responsible, and corrects itself.
Repeat: The loop continues until the validation command returns an Exit Code 0.

4. Visualizing the Agentic Loop

graph TD
    User[Goal: Upgrade API] --> Research[Phase 1: Research Codebase]
    Research --> Strategy[Phase 2: Propose Strategy]
    Strategy -- User Review / Approval --> Execution[Phase 3: Execution Loop]
    
    subgraph "The Execution Loop (Autonomous)"
        Act[Surgical Edit] --> Validate[Run Build & Tests]
        Validate -- Fail --> ReadLog[Read Stack Trace]
        ReadLog --> Act
        Validate -- Pass --> Done[Goal Achieved]
    end

5. Practical Example: Autonomous Bug Fixing

Imagine a bug where "Users can't sign up with emails containing a plus sign (+)."

The Beginner Way: "Fix the email regex." (AI might change a regex that breaks existing unicode support).

The Staff-Tier Agentic Way:

Research: "Find where email validation occurs. Find the existing test suite for user signups."
Reproduction: "Create a temporary reproduction test file repro_plus_sign.test.ts that fails with a '+' email."
Strategy: "I will update the regex in ValidationUtils.ts to support RFC-compliant '+' signs. I will then run the reproduction test and the full suite."
Execution: Apply fix $\rightarrow$ Run test $\rightarrow$ Verify pass $\rightarrow$ Delete reproduction file.

6. Advanced Concept: The "Wait for Previous" Flag

In complex agentic scripts, you often have tasks that depend on the results of others. If you ask Claude Code to "Install the AWS SDK, then write a S3 service," these tasks cannot happen in parallel.

When prompting, you can influence the agent's concurrency logic. "Install the package using npm. Wait for the install to finish successfully before creating the new file in the /lib folder."

This forces the agent to use the wait_for_previous: true flag in its internal tool calls, ensuring the file system is in the correct state for the next step.

Final Takeaway

Stop giving "Orders." Start giving "Objectives." A well-researched strategy is the difference between a surgical update and a breaking change. By following the Research -> Strategy -> Execution cycle, you empower Claude Code to act as a true senior partner rather than just a sophisticated text-completer.

The result is code that is verified, integrated, and architecturally sound.