# ❌ NEVER do this
Read entire file: src/services/userService.ts

# ✅ ALWAYS do this
Read lines 1-30: src/services/userService.ts  # imports + interface
Read lines 45-60: src/services/userService.ts  # specific function

# List files (no content)
ls -la src/services/

# Find specific file
find . -name "*.service.ts"

# Read just imports
head -30 src/services/user.service.ts

# Read specific lines
sed -n '45,60p' src/services/user.service.ts

# Find function location
grep -n "function getUserById" src/services/user.service.ts

Is task simple (list, read, simple edit)?
  YES → Haiku (save 90%+)
  NO → Does task require complex reasoning?
    NO → Sonnet
    YES → Is it architecture/design decision?
      YES → Opus
      NO → Try Sonnet first, Opus if fails

# .autopilot/learnings.md

## Project Structure (CACHED - don't re-read)

## Key Types (CACHED - don't re-read types.ts)
```typescript
interface User { id: string; email: string; role: Role }
interface Order { id: string; userId: string; total: number }
type Role = 'admin' | 'user' | 'guest'

### Before Reading Any File

---

## 4. BATCHING OPERATIONS

### Bad: Separate Tasks

### Good: Batched Task

### Batching Rules

| Batch Together | Keep Separate |
|----------------|---------------|
| Same feature files | Different features |
| Create + export | Create + full test suite |
| Multiple simple edits | Complex + simple |
| Related configs | Unrelated configs |

---

## 5. CONCISE OUTPUT

### Bad: Verbose

```markdown
I will now proceed to create the UserService class. This service 
will be responsible for handling all user-related operations 
including creating new users, retrieving users by their ID, 
updating user information, and deleting users from the system.

The service will follow the repository pattern that I observed
in the existing codebase, specifically matching the patterns
found in OrderService and ProductService...

[200 more tokens of explanation]

Here is the implementation:
[code]

I have successfully created the UserService. The service includes
four main methods: createUser, getUserById, updateUser, and 
deleteUser. Each method properly handles errors and follows
the established patterns...

[150 more tokens of summary]

Creating UserService (CRUD, matches existing pattern).

[code]

✅ UserService created

IF previous task passed build/lint/tests
AND current task modifies DIFFERENT files
THEN skip full validation
ONLY run tests for current changes

Total: 200K tokens

Smart allocation:
- System: 10K (fixed)
- Cached info: 5K (learnings.md summary)
- Current phase: 5K (minimal)
- Active task: 15K (only relevant files)
- Working buffer: 30K
- Response: 30K
- CHECKPOINT at 40% (not 50%!)

## Spawning: backend agent

I need you to create a new UserService class. This class should
be located in src/services/userService.ts. The service needs to
implement CRUD operations for users. Please follow the existing
patterns in the codebase. The service should use dependency 
injection for the repository. Make sure to handle all errors
properly and add appropriate TypeScript types.

Here is the full content of the existing OrderService for reference:
[500 lines of code]

And here is the ProductService:
[400 lines of code]

And the repository interface:
[200 lines of code]

## Spawning: backend

**Task:** Create UserService (CRUD)
**File:** src/services/userService.ts
**Pattern:** Match OrderService (see learnings.md)
**Inject:** UserRepository

Read all 50 source files → Plan → Execute
(Wastes tokens on files you won't modify)

Read structure only → Plan → 
  Task 1: Read only task1 files → Execute
  Task 2: Read only task2 files → Execute
  ...

□ Am I reading the minimum necessary?
□ Is this info already cached in learnings.md?
□ Can I use Haiku instead of Sonnet?
□ Can I batch this with related work?
□ Will my output be concise?
□ Am I re-validating unnecessarily?
□ Am I at 40% context? (checkpoint time)