# "Don’t Outsource Your Thinking" to your Agent

Source: https://www.youtube.com/watch?v=NjjEkmP2C8k
Recap page: https://rapidrecap.app/video/NjjEkmP2C8k
Generated: 2026-01-22T14:03:44.988+00:00

---
## Quick Overview

Effective use of AI coding agents requires adopting a disciplined process centered on planning, incremental development (small chunks), maintaining human oversight (staying in the loop), and leveraging tools like Git for safety, rather than outsourcing critical thinking or relying on multi-agent systems without skepticism.

**Key Points:**
- AI coding agents can make developers faster, but only if they avoid outsourcing their thinking; the meta-skill is learning to learn, not just getting answers (00:00-00:26).
- The recommended workflow involves a 15-minute waterfall process: brainstorm requirements with the AI, compile into a spec document, generate a step-by-step plan, and only then start coding (02:35-02:58).
- Context rot, where irrelevant information in the context window hurts the LLM's performance, is real, leading to forgotten tasks or ignored question halves; fix this by using /clear or /catchup commands (01:54-02:31).
- Developers must act as the Senior Engineer, reading, running, and testing every AI-generated snippet as if it came from a junior developer, and never merging code they cannot explain (04:13-05:03).
- Tests are force multipliers: without them, agents are blind and assume everything is fine; the pattern is Write code -> Run tests -> Fix failures -> Repeat (05:17-05:36).
- When using multi-agent systems, be skeptical, as 10 sub-agents introduce 10 potential sources of failure, which can become extremely cumbersome to debug (07:44-08:07).
- Use Git frequently, treating commits as save points in a game, and ground your model by providing it with context via a CLAUDE.md file containing project style and thinking rules (08:11-09:06).

![Screenshot at 01:34: A slide contrasting 'Outsourcing Thinking' \(bad prompts like 'What is wrong with this code?'\) against 'Learning to Learn' \(better prompts like 'What techniques can I use to understand the effects of X?'\), emphasizing that the meta-skill is learning how to learn, not just receiving answers.](https://ss.rapidrecap.app/screens/NjjEkmP2C8k/00-01-34.jpg)

**Context:** This presentation outlines seven key lessons for effectively integrating AI coding agents, such as Claude, into a developer's workflow over a year of experience. The core philosophy rejects outsourcing critical thinking to the AI, instead advocating for a structured, iterative process that keeps the human engineer in control. Key concepts introduced include managing context rot, employing a 'chunk strategy' for development, recognizing the limitations of AI in high-level design, and utilizing version control (Git) as a safety net.

## Detailed Analysis

The presentation argues that AI coding agents accelerate development only if the user maintains strong engineering fundamentals and avoids outsourcing their thinking; the key meta-skill is learning how to learn from the AI, not simply asking for solutions. The recommended workflow is a rapid, 15-minute waterfall process: brainstorm requirements, compile them into a specification document, generate a step-by-step plan, and then begin coding. A major pitfall identified is "Context Rot" (01:54), where irrelevant information in the context window causes the LLM to forget instructions or ignore parts of the prompt, which is fixed by using commands like /clear or /catchup. Developers must adopt a 'Chunk Strategy' (03:42), breaking down large requests into small, testable steps, because LLMs excel at quick, contained tasks. Furthermore, the developer must assume the role of the Senior Engineer (04:13), treating every AI output as if it came from a junior developer—reading, running, and testing it—and never merging code they cannot explain. Tests are crucial force multipliers; without them, agents operate blindly, assuming correctness. Finally, grounding the model with project context via a specific file (like CLAUDE.md) and exercising skepticism towards multi-agent systems (which introduce multiple failure points) are essential for maximizing productivity while maintaining control.

### Initial Premise

- AI can make you faster or worse, depending on how you use it
- The core philosophy is 'Don't Outsource Your Thinking' and focus on 'learning to learn' (00:00-00:26)

### Lesson 1

- Context Rot Is Real: Irrelevant context causes the LLM to forget tasks or ignore parts of the question
- Fix this by using /clear or /catchup commands to refocus the agent (01:54-02:31)

### Lesson 2

- Plan First, Code Later: Implement a 'Waterfall in 15 Minutes' process (Brainstorm -> Spec -> Plan -> Code) to reduce ambiguity and ensure both human and AI know the goal (02:35-03:15)

### Lesson 3

- Small Chunks Beat Big Prompts: Avoid asking for monolithic outputs (e.g., 'Build me an entire authentication system'); instead, follow a test-driven development pattern by implementing steps sequentially (03:42-04:07)

### Lesson 4

- You Are the Senior Engineer: Treat every AI snippet like output from a junior developer—read it, run it, test it, and never commit code you cannot explain (04:13-05:03)

### Lesson 5

- Tests Are Force Multipliers: Without tests, agents are blind; use the write code -> run tests -> fix failures pattern, as tests are the safety net (05:17-05:36)

### Lesson 6

- Ground Your Model: Provide context via a document like CLAUDE.md to keep the agent aligned with project style and architectural decisions throughout multi-session projects (05:37-06:47)

### Lesson 7

- Know When NOT to Use Agents: Avoid using agents for exploratory work (which leads to infinite loops) or high-level architectural decisions that require human judgment (06:48-07:40)

![Screenshot at 00:08: Text overlay highlighting the dual nature of AI coding agents: 'They can make you faster. They can also make you worse.'](https://ss.rapidrecap.app/screens/NjjEkmP2C8k/00-00-08.jpg)
![Screenshot at 01:34: A visual comparison between 'Outsourcing Thinking' \(bad prompts\) and 'Learning to Learn' \(better prompts\), illustrating the shift from asking for solutions to asking for techniques.](https://ss.rapidrecap.app/screens/NjjEkmP2C8k/00-01-34.jpg)
![Screenshot at 02:49: The 'Waterfall in 15 Minutes' process steps: 1. Brainstorm requirements, 2. Compile into spec.md, 3. Generate step-by-step plan, 4. Only then start coding.](https://ss.rapidrecap.app/screens/NjjEkmP2C8k/00-02-49.jpg)
![Screenshot at 05:23: The slide 'Without Tests, Agents Are Blind,' noting that agents blithely assume everything is fine without a test suite, contrasting with the 'Pattern' of Write code -\> Run tests -\> Fix failures -\> Repeat.](https://ss.rapidrecap.app/screens/NjjEkmP2C8k/00-05-23.jpg)
![Screenshot at 10:01: A diagram illustrating 'The Virtuous Cycle': Better Engineering Fundamentals leads to Better AI Results, which creates More Learning Opportunities, looping back to better fundamentals.](https://ss.rapidrecap.app/screens/NjjEkmP2C8k/00-10-01.jpg)