Context Window Limits: Practical Solutions for AI Development

# CRITICAL CONTEXT - NEVER TRUNCATE

## Current Task
[Specific thing you're building right now]

## Core Files  
[2-3 files you're actively working on]

## Key Types/Interfaces
[Essential data structures]

## Immediate Context
[Last 3-4 conversation exchanges]

# IMPORTANT CONTEXT - INCLUDE IF SPACE

## Project Overview
[Brief description of what you're building]

## Related Files
[Dependencies, utilities, related components]

## Architecture Notes
[Key design decisions, patterns used]

## Recent Changes  
[What was implemented recently]

# REFERENCE CONTEXT - LINK TO EXTERNAL

## Documentation
[Link to relevant docs, don't paste full text]

## Similar Solutions
[Brief mention + link to example code]

## Full Project Structure
[High-level overview, not file-by-file listing]

# Instead of full file content:
```typescript
// 500 lines of React component code
```

# Use structured summary:
## UserProfile.tsx Summary
- **Purpose**: User profile management component
- **Key Props**: userId, onUpdate, readOnly
- **State**: profileData, isEditing, saveStatus
- **Key Functions**: 
  - handleSave(): Validates + saves profile changes
  - handleAvatarUpload(): Processes file upload to S3
  - handleCancel(): Reverts unsaved changes
- **Dependencies**: useUserData hook, S3Client, ValidationSchema
- **Tests**: Profile loading, save functionality, upload flow

# CONVERSATION SUMMARY
## What We've Accomplished
- ✅ Set up user profile API endpoints
- ✅ Implemented profile validation logic  
- ✅ Created database schema for user profiles
- ✅ Added unit tests for profile service

## Current Focus
- Working on: React component for profile editing
- Next up: Avatar upload functionality
- Blocked on: S3 bucket configuration

## Key Decisions Made
- Using React Hook Form for form state
- Validating on client + server side
- Storing avatars in S3, URLs in database
- Using optimistic updates for better UX

## Code Standards Established
- TypeScript strict mode
- Zod for validation schemas
- Jest + Testing Library for tests
- Tailwind for styling

# SESSION BRIDGE DOCUMENT

## Previous Session Summary
[2-3 paragraphs summarizing what was accomplished]

## Current State
[What files were changed, what's working, what's not]

## Context Handoff
```typescript
// Key code snippets from previous session
// Include ONLY the most critical pieces
```

## Next Steps
[Exactly what you want to work on next]

## Critical Context
[Any specific decisions, patterns, or constraints that must be remembered]

src/
  features/
    user-profile/           # All profile-related code together
      components/
        UserProfile.tsx     
        AvatarUpload.tsx
      hooks/
        useUserData.ts
        useAvatarUpload.ts
      types/
        profile.types.ts
      tests/
        UserProfile.test.tsx
        useUserData.test.ts
      index.ts              # Feature exports
  
  shared/                   # Context-independent utilities
    components/
    hooks/
    utils/

# CONTEXT_MANIFEST.md

## Essential Files for AI Context
### Always Include
- `src/types/index.ts` (core types)
- `src/config/constants.ts` (key constants)  
- `.env.example` (environment structure)

### Feature-Specific Context
#### User Profile Feature
- `src/features/user-profile/index.ts`
- `src/features/user-profile/types/profile.types.ts`
- `src/features/user-profile/hooks/useUserData.ts`

#### Authentication Feature  
- `src/features/auth/index.ts`
- `src/features/auth/types/auth.types.ts`
- `src/features/auth/hooks/useAuth.ts`

## Context Budget
- **Critical files:** ~30k tokens
- **Feature files:** ~50k tokens per feature
- **Conversation:** ~20k tokens
- **Total budget:** ~100k tokens (within GPT-4 limits)

# Context Rotation Script

function get_context_for_task() {
    local task="$1"
    
    case "$task" in
        "frontend")
            echo "Including: React components, hooks, types"
            cat src/components/*.tsx src/hooks/*.ts src/types/*.ts
            ;;
        "backend") 
            echo "Including: API routes, services, schemas"
            cat src/routes/*.ts src/services/*.ts src/schemas/*.ts
            ;;
        "testing")
            echo "Including: Test files, utilities, fixtures"
            cat src/**/*.test.ts src/test-utils/*.ts
            ;;
    esac
}

# Usage: get_context_for_task "frontend"

#!/bin/bash
# smart-context.sh - Generate context relevant to current changes

echo "# Smart Context for Current Work"
echo "## Recently Changed Files"

# Files changed in last 3 commits
git diff --name-only HEAD~3..HEAD | while read file; do
    if [[ -f "$file" && "$file" =~ \.(ts|tsx|js|jsx)$ ]]; then
        echo "### $file"
        echo '```typescript'
        head -50 "$file"  # First 50 lines only
        echo '```'
        echo
    fi
done

echo "## Related Files (by import)"
# Find files that import the changed files
# (Implementation depends on your project structure)

echo "## Current Branch Context"
echo "**Branch:** $(git branch --show-current)"
echo "**Recent commits:**"
git log --oneline -3

# Multi-Model Workflow

## Step 1: Planning (Gemini 2M context)
- Include entire codebase
- Generate architecture plan
- Create detailed task breakdown
- Output: Structured plan document

## Step 2: Implementation (Claude 200k context)
- Include plan + relevant files only
- Focus on code generation
- One feature at a time
- Output: Working code

## Step 3: Review (GPT-4 128k context)
- Include new code + tests
- Focus on edge cases and optimization
- Code review and suggestions
- Output: Refined implementation

# Context Compression Prompt

You are a context compression specialist. I need to summarize this codebase context to fit in a smaller context window while preserving all information needed for development work.

Original context: [paste your full context]

Create a compressed version that includes:
1. All essential type definitions (full)
2. Function signatures only (not full implementations)  
3. Key architectural decisions
4. Current task and requirements
5. Critical dependencies and patterns

Maintain enough detail for continued development work, but remove redundant code and verbose explanations.

# context-state.json
{
  "session_id": "2026-03-31-user-profile",
  "total_tokens": 85000,
  "context_breakdown": {
    "current_task": 8000,
    "code_files": 45000, 
    "conversation": 15000,
    "documentation": 12000,
    "types": 5000
  },
  "priority_files": [
    "src/components/UserProfile.tsx",
    "src/hooks/useUserData.ts", 
    "src/types/profile.types.ts"
  ],
  "next_session_bridge": {
    "completed": ["profile API", "validation"],
    "in_progress": ["React component"],
    "next_up": ["avatar upload", "tests"]
  }
}

#!/bin/bash
# context-budget.sh

function estimate_tokens() {
    local file="$1"
    # Rough estimate: 4 characters per token
    if [[ -f "$file" ]]; then
        local chars=$(wc -c < "$file")
        echo $((chars / 4))
    fi
}

total_tokens=0
echo "# Context Budget Analysis"

for file in "$@"; do
    tokens=$(estimate_tokens "$file")
    total_tokens=$((total_tokens + tokens))
    echo "- $file: ~$tokens tokens"
done

echo
echo "Total estimated tokens: $total_tokens"

# Check against model limits
if [[ $total_tokens -gt 100000 ]]; then
    echo "⚠️  Exceeds GPT-4 limit (128k)"
    echo "✅ Within Gemini limit (2M)"
elif [[ $total_tokens -gt 150000 ]]; then
    echo "⚠️  Exceeds Claude limit (200k)"
else
    echo "✅ Within all model limits"
fi

#!/bin/bash
# generate-context-template.sh

cat << 'EOF'
# AI Context Template - $(date)

## Current Task
[What are you building right now?]

## Priority Files
```typescript
// Include 2-3 most important files here
```

## Project Context
- **Tech Stack**: [Your stack]
- **Architecture**: [Your architecture]
- **Current Phase**: [What you're working on]

## Standards
- [Your coding standards]
- [Testing approach]
- [Documentation style]

## Success Criteria
- [ ] [Specific deliverable 1]
- [ ] [Specific deliverable 2] 
- [ ] [Specific deliverable 3]

---
# Reference (include if space allows)
[Additional context, docs, examples]
EOF