The Context-First Process

The key insight: AI needs massive context BEFORE writing code, unlike human development where the developer already has context in their head.

The Context Pyramid

Your effectiveness with AI depends on how well you build context from the ground up.

                        ▲
                       /░\        1. USER RULES (.cursorrules)
                      /░░░\           (Identity + Guardrails)
                     /░░░░░\
                    /▓▓▓▓▓▓▓\     2. READ CODEBASE STRUCTURE
                   /▓▓▓▓▓▓▓▓▓\        (Architecture Context)
                  /▓▓▓▓▓▓▓▓▓▓▓\
                 /▒▒▒▒▒▒▒▒▒▒▒▒▒\   3. READ SPECIFIC FILES
                /▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒\      (Implementation Details)
               /▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒\
              /███████████████████\  4. RESEARCH DOCS + ONLINE
             /█████████████████████\     (External Knowledge)
            /███████████████████████\
           /▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓\  5. WRITE CODE + TESTS
          /▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓\     (Implementation)
         /▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓\
        /▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒\  6. RUN TESTS + COMPILATION
       /▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒\     (Validation Layer)
      /▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒\
     /█████████████████████████████████████████\  7. LOG → FIX → REPEAT
    /███████████████████████████████████████████\     (Feedback Loop)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
              IDENTITY → EXECUTION → MASTERY

Each layer builds on the one above. You can't effectively write code (5) without research (4), and you can't research effectively without understanding the codebase (2-3).

The 7 Steps Explained

Load User Rules

Your .cursorrules file (or equivalent) sets the AI's identity and guardrails. This is the foundation everything builds on.

# .cursorrules example
- Use TypeScript strict mode
- Never commit secrets
- Single responsibility principle
- Minimize dependencies
- Test everything

What this does: Gives AI a "senior developer" identity with your coding standards baked in.

Index the Codebase

Let AI understand your project's architecture and structure before diving into specifics.

"Read the project structure. Understand the folder organization,
key dependencies in package.json, and overall architecture."

What this does: AI understands where things live and how they connect.

Read Specific Files

Once AI knows the structure, point it to the exact files relevant to your task.

"Read /src/services/AuthService.ts and /src/utils/validation.ts.
Understand how authentication currently works."

What this does: AI becomes an expert on the specific implementation you're modifying.

Research Docs & Online

Before writing code, have AI research best practices and documentation.

"Research the NextAuth.js documentation for credential providers.
Look up best practices for password hashing in 2024."

What this does: Ensures AI uses current, correct approaches—not outdated patterns.

Write Code + Tests

Now—and only now—write implementation code alongside tests.

"Implement the password reset flow. Write the implementation
AND the test file simultaneously. Follow TDD principles."

What this does: Code and tests are born together, ensuring testability.

Run Tests + Compilation

Execute tests and build to validate the implementation.

npm run test
npm run build
npm run lint

What this does: Catches errors before they become commits.

Log → Fix → Repeat

When tests fail, use logs to debug and iterate.

"Here's the test failure output. Read the logs, identify the issue,
fix the code, and we'll run tests again."

What this does: Creates a tight feedback loop until everything passes.

The Development Cycle

The same process as a continuous loop:

                 ┌─────────────────────────────────────┐
                 │   1. RULES                          │
                 │   Load .cursorrules / user rules    │
                 │   (Sets identity & guardrails)      │
                 └────────────────┬────────────────────┘
                                  │
                                  ▼
┌───────────────────────────────────────────────────────────────┐
│                                                               │
│   ┌─────────────┐      ┌─────────────┐      ┌─────────────┐  │
│   │ 2. INDEX    │ ───► │ 3. READ     │ ───► │ 4. RESEARCH │  │
│   │ Codebase    │      │ Specific    │      │ Docs/Web    │  │
│   │ Structure   │      │ Files       │      │             │  │
│   └─────────────┘      └─────────────┘      └─────────────┘  │
│                                                               │
│                    CONTEXT GATHERING PHASE                    │
└───────────────────────────┬───────────────────────────────────┘
                            │
                            ▼
              ┌─────────────────────────────┐
              │   5. WRITE CODE + TESTS     │
              │   (Implementation)          │
              └─────────────┬───────────────┘
                            │
                            ▼
              ┌─────────────────────────────┐
              │   6. RUN + COMPILE + TEST   │
              │   (Validation)              │
              └─────────────┬───────────────┘
                            │
              ┌─────────────▼───────────────┐
              │   7. READ LOGS + FIX        │◄────┐
              │   (Debug Loop)              │     │
              └─────────────┬───────────────┘     │
                            │                     │
                            └──────── ❌ ─────────┘
                            │
                            ✓
                            ▼
              ┌─────────────────────────────┐
              │   ✅ COMMIT + SHIP          │
              └─────────────────────────────┘

How This Differs from Traditional TDD

Traditional TDD	Context-First Process	Key Difference
1. Write Test	1-4. Build Context	You front-load understanding
2. Run (Fail)	5. Write Code+Test	AI-assisted implementation
3. Write Code	6. Run Tests	Same validation
4. Run (Pass)	7. Debug Loop	Same iteration
5. Refactor	✅ Commit	Same outcome

⚠️

The crucial insight: Traditional TDD assumes the developer already has context in their head. With AI, you must explicitly build that context through steps 1-4 before any code is written.

Why This Works

Guardrails First — User rules prevent AI from making common mistakes
Architecture Awareness — AI understands how pieces fit together
Implementation Knowledge — AI knows the actual code patterns in use
Current Best Practices — Research prevents outdated solutions
Test-Driven — Code and tests are created together
Validated — Nothing ships without passing tests
Iterative — Failures become learning opportunities

"The quality of AI output is directly proportional to the quality of context you provide."

Horizon Thinking Project Setup