context-gathering

# Context Gathering Skill

> **Core Principle**: Understand before acting.

## When to Invoke

- Starting work in an unfamiliar codebase
- Beginning a new feature implementation
- Before modifying code you haven't worked with before
- When requirements reference parts of the system you don't understand
- After a context switch to a different area of the codebase

## Exploration Protocol

Execute these phases in order. Do not skip phases.

### Phase 1: Architecture

**Objective**: Build mental map of the system.

```
1. Read documentation:
   - README.md (project purpose, setup)
   - docs/ directory (if exists)
   - CONTRIBUTING.md (conventions)
   - ARCHITECTURE.md (if exists)

2. Identify entry points:
   - Main entry file (main.py, index.ts, etc.)
   - CLI entry points
   - API routes/handlers
   - Event handlers

3. Map directory structure:
   - What does each top-level directory contain?
   - Where does business logic live?
   - Where are tests?
   - Where is configuration?
```

### Phase 2: Patterns

**Objective**: Understand existing conventions.

```
1. Find similar features:
   - Search for implementations like what you'll build
   - Note how they're structured
   - Identify reusable patterns

2. Identify coding conventions:
   - Naming patterns (camelCase, snake_case, etc.)
   - File organization (one class per file? grouped by feature?)
   - Error handling patterns
   - Logging patterns

3. Note test patterns:
   - Test file naming
   - Test structure (describe/it, test classes, etc.)
   - Mocking patterns
   - Test data patterns
```

### Phase 3: Dependencies

**Objective**: Understand external connections.

```
1. Check dependency files:
   - package.json / requirements.txt / Cargo.toml / etc.
   - Lock files for exact versions

2. Identify external services:
   - Databases
   - APIs
   - Message queues
   - Cache systems

3. Note version constraints:
   - Language version requirements
   - Framework version requirements
   - Breaking change warnings
```