Horizon Thinking

AI thinks vertically. You provide the horizontal.

The Core Visual

                              YOU
                               │
         ◄─────────────────────┼─────────────────────►  HORIZONTAL
                               │                        (Your Context)
         Patterns              │              Constraints
         History               │              Integrations
         Domain Knowledge      │              Future Plans
                               │
                               │
                              ─┼─
                               │
                               │  AI
                               │
                               ▼  VERTICAL
                                  (AI Implementation)

AI can only move vertically — straight down from prompt to implementation.

You control the horizontal — where on the landscape the AI aims.

The Two Dimensions

┌────────────────────────────────────────────────────────────────────────┐
│                                                                        │
│   HORIZONTAL (You)                    VERTICAL (AI)                    │
│   ════════════════                    ═════════════                    │
│                                                                        │
│   ← Past ──────────── Present ──────────── Future →                    │
│                           │                                            │
│   • Why things exist      │      • "Build this feature"                │
│   • What patterns to use  │              │                             │
│   • What constraints      │              ▼                             │
│   • What integrations     │      • Top-to-bottom                       │
│   • Domain knowledge      │        implementation                      │
│   • Business rules        │              │                             │
│                           │              ▼                             │
│                           │      • Working code                        │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘

Without vs. With Horizontal Context

❌ WITHOUT YOUR HORIZONTAL CONTEXT
══════════════════════════════════

        "Add login"
             │
             │  AI implements straight down
             │  from the only point it knows
             ▼
      ┌─────────────┐
      │ Basic login │  ← Generic, doesn't fit your system
      │ (generic)   │
      └─────────────┘


✅ WITH YOUR HORIZONTAL CONTEXT  
═══════════════════════════════

   JWT ───── SSO ───── Rate Limit ───── Audit ───── GDPR
                           │
                           │  "Add login with JWT,
                           │   integrate SSO, rate limit,
                           │   log to audit system"
                           │
                           ▼
                    ┌─────────────┐
                    │ Perfect fit │  ← Integrates with your system
                    │ for YOUR    │
                    │ system      │
                    └─────────────┘

The Intersection

                    YOUR HORIZONTAL CONTEXT
                    
    Patterns    Constraints    Integrations    History
        │            │              │             │
        └────────────┴──────┬───────┴─────────────┘
                            │
    ════════════════════════╪════════════════════════════
                            │
                            │ ← THE INTERSECTION
                            │    Your context + AI's power
                            │    = Correct implementation
                            │
                            ▼
                            
                    AI'S VERTICAL POWER
                    
                    "I can build anything
                     top-to-bottom...
                     
                     ...but only from the
                     point YOU place me."

The Formula

Horizontal Context (what you provide) × Vertical Power (what AI does) = Correct Output

Missing horizontal = AI builds in the wrong place.

QUALITY OF OUTPUT = HORIZONTAL CONTEXT × VERTICAL EXECUTION

   Your Context:     10%  ──►  AI builds generic code (wrong patterns)
   Your Context:     50%  ──►  AI builds decent code (some integration)
   Your Context:     90%  ──►  AI builds perfect fit (your system exactly)

What Goes on Each Axis

HORIZONTAL (You Provide)	VERTICAL (AI Executes)
Existing systems to integrate	Feature implementation
Patterns to follow	Function logic
Constraints (no new deps, bundle size)	Error handling
History (why things are this way)	API design
Future plans (multi-tenancy later)	Database queries
Domain knowledge	Testing
Business rules	Documentation

The Horizon Checklist

Before every prompt, expand the horizontal:

□ INTEGRATIONS   "This connects to [existing system]"
□ PATTERNS       "Follow the pattern in [file]"
□ CONSTRAINTS    "Cannot use [limitation]"
□ HISTORY        "We use X because [reason]"
□ FUTURE         "Must support [planned feature] later"
□ DOMAIN         "Users typically [behavior]"
□ ENVIRONMENT    "In prod we use [difference]"

Example: Email Feature

❌ Narrow Horizontal (Bad)

Prompt: "Add a function to send notification emails"

         │
         ▼
    Generic nodemailer
    Hardcoded addresses
    No templates
    No rate limiting
    No GDPR compliance

✅ Wide Horizontal (Good)

Horizontal context you provide:
├── SendGrid (configured in /src/lib/email.ts)
├── Template system in /src/templates  
├── env.EMAIL_FROM for addresses
├── GDPR: must include unsubscribe
├── Rate limit: 10/user/hour
└── Follow sendWelcomeEmail() pattern

         │
         ▼
    Uses SendGrid
    Uses your templates
    Respects rate limits
    GDPR compliant
    Matches your patterns

When Output is Wrong

Ask: "What horizontal context did I miss?"

Wrong output?
     │
     ▼
┌─────────────────────────────────┐
│  AI isn't broken.               │
│  Your horizontal was incomplete.│
│                                 │
│  What did AI NOT know?          │
│  • Existing service?            │
│  • Pattern to follow?           │
│  • Constraint?                  │
│  • Integration?                 │
│  • Business rule?               │
│                                 │
│  Add it. Try again.             │
└─────────────────────────────────┘

Key Takeaways

⚠️

The AI is never "wrong" — it's building from where you placed it.

Bad output = you aimed the vertical power at the wrong horizontal point.

AI = Vertical — Implements straight down, powerfully
You = Horizontal — Position where the AI aims
Intersection = Output — Quality depends on your context
Wrong output? — Widen your horizontal, not blame the vertical

"AI can drill to any depth. You choose where to drill."

Tornado Building The 7-Step Process