Context Engineering: The Art of AI Understanding

        🎯 Desired Output
      ╱───────────────────╲
     ╱     Specific       ╲
    ╱      Task Context   ╲
   ╱─────────────────────── ╲
  ╱    Domain Knowledge    ╲
 ╱      & Constraints       ╲
╱─────────────────────────────╲
 System Context & Environment

I'm working on a Node.js microservices architecture with:
- Express.js for API routes
- PostgreSQL with Prisma ORM
- Redis for caching
- JWT authentication
- TypeScript throughout
- Jest for testing

This is an e-commerce platform handling:
- User accounts and authentication
- Product catalog with inventory
- Shopping cart and checkout flow
- Order processing and fulfillment
- Payment integration with Stripe

I need to implement the shopping cart service that:
- Persists cart data across sessions
- Handles concurrent modifications
- Validates inventory before checkout
- Calculates taxes and shipping
- Integrates with our existing user service

# Project Context Template

## Tech Stack
- **Frontend:** React 18 + TypeScript + Vite
- **Backend:** Node.js + Express + TypeScript  
- **Database:** PostgreSQL + Prisma
- **Auth:** Auth0 JWT tokens
- **Deployment:** Docker + AWS ECS
- **Testing:** Jest + Cypress

## Architecture Patterns
- Clean Architecture with dependency injection
- Repository pattern for data access
- Service layer for business logic
- API Gateway pattern for external requests
- Event-driven communication between services

## Coding Standards
- ESLint + Prettier configuration
- Conventional commits
- 100% TypeScript strict mode
- Comprehensive error handling
- Security-first development

Following the context in project-context.md, create a user authentication service...

function buildAIContext(operation, files, userInput) {
  const context = {
    system: getSystemContext(),
    project: getProjectContext(),
    current: getCurrentFileContext(files),
    operation: getOperationContext(operation),
    user: processUserInput(userInput)
  };
  
  return formatContextForAI(context);
}

// Usage
const prompt = buildAIContext('create-component', activeFiles, userRequest);

CONVERSATION HISTORY:
Session: 2024-01-15 - Shopping Cart Feature
Previous Actions:
1. Created cart model with validation
2. Implemented add/remove item methods  
3. Added inventory checking logic
Current Task: Implement cart persistence layer
Context: User wants Redis caching for performance

CODE EVOLUTION CONTEXT:
File: services/CartService.ts
Changes Made:
- v1.0: Basic in-memory cart operations
- v1.1: Added validation and error handling  
- v1.2: Integrated with inventory service
Current Version: v1.2
Next: Add Redis persistence layer
Dependencies: Redis client, cart interface

PROJECT CONTEXT GRAPH:
Current File: components/ShoppingCart.tsx
Dependencies:
├── hooks/useCart.ts (custom cart hook)
├── services/CartService.ts (business logic)  
├── types/Cart.ts (TypeScript interfaces)
├── styles/Cart.module.css (component styles)
└── utils/CartValidation.ts (validation logic)

Related Files (2-hop dependencies):
├── services/InventoryService.ts
├── contexts/UserContext.tsx
└── api/cart-endpoints.ts

INSTRUCTIONS: When modifying ShoppingCart.tsx, ensure 
compatibility with all listed dependencies and related files.

COMPRESSED PROJECT CONTEXT:
Architecture: React + Node.js microservices
Key Patterns: Repository pattern, dependency injection
Current Module: User management system
Related APIs: /users, /auth, /profiles
Data Models: User, Profile, AuthToken
Key Constraints: GDPR compliance, under 200ms response time

function getRelevantContext(currentTask, projectSize) {
  if (projectSize > 1000) {
    return getCompressedContext(currentTask);
  } else {
    return getFullContext(currentTask);
  }
}

✅ System information provided
✅ Domain knowledge included  
✅ Task requirements clear
✅ Constraints specified
✅ Success criteria defined
✅ Examples provided
✅ Edge cases mentioned
✅ Dependencies identified

// Context testing scenarios
const testScenarios = [
  {
    name: "Simple CRUD operation",
    context: "minimal",
    expected: "basic implementation"
  },
  {
    name: "Complex business logic",
    context: "full",
    expected: "comprehensive solution"
  },
  {
    name: "Legacy code integration",
    context: "historical",
    expected: "compatible implementation"
  }
];

function testContextEffectiveness(scenario) {
  const context = buildContext(scenario.contextType);
  const result = queryAI(context + scenario.task);
  return evaluateResult(result, scenario.expected);
}

class ContextRepository {
  constructor() {
    this.contexts = new Map();
    this.templates = new Map();
    this.history = [];
  }
  
  registerTemplate(name, template) {
    this.templates.set(name, template);
  }
  
  buildContext(templateName, variables) {
    const template = this.templates.get(templateName);
    return this.interpolateContext(template, variables);
  }
  
  saveContextSnapshot(sessionId, context) {
    this.contexts.set(sessionId, {
      context,
      timestamp: Date.now(),
      version: this.getNextVersion()
    });
  }
  
  getContextHistory(sessionId) {
    return this.history.filter(h => h.sessionId === sessionId);
  }
}

class SmartContextSelector {
  selectOptimalContext(task, projectInfo, userPreferences) {
    const contextStrategy = this.analyzeTask(task);
    
    switch(contextStrategy) {
      case 'minimal':
        return this.buildMinimalContext(projectInfo);
      case 'comprehensive':
        return this.buildFullContext(projectInfo);
      case 'specialized':
        return this.buildSpecializedContext(task, projectInfo);
      default:
        return this.buildAdaptiveContext(task, projectInfo);
    }
  }
  
  analyzeTask(task) {
    const complexity = this.calculateComplexity(task);
    const scope = this.determineScope(task);
    const dependencies = this.analyzeDependencies(task);
    
    return this.selectStrategy(complexity, scope, dependencies);
  }
}

Global Context
├── Organization Standards
│   ├── Security Policies
│   ├── Coding Guidelines
│   └── Architecture Principles
├── Project Context
│   ├── Tech Stack
│   ├── Business Domain
│   └── Team Conventions
└── Session Context
    ├── Current Files
    ├── Recent Changes
    └── User Intent

const contextVersioning = {
  v1: {
    format: "simple text blocks",
    capabilities: ["basic task description"]
  },
  v2: {
    format: "structured sections",
    capabilities: ["task + constraints + examples"]
  },
  v3: {
    format: "hierarchical context tree",
    capabilities: ["dynamic context selection", "memory persistence"]
  }
};

function upgradeContextVersion(oldContext, targetVersion) {
  return contextMigrations[targetVersion](oldContext);
}

function fuseContextSources(sources) {
  const fusion = {
    system: mergeSystems(sources.map(s => s.system)),
    domain: combineDomains(sources.map(s => s.domain)),
    task: prioritizeTasks(sources.map(s => s.task)),
    constraints: unionConstraints(sources.map(s => s.constraints))
  };
  
  return optimizeContextSize(fusion);
}

const contextMetrics = {
  usage: {
    totalRequests: 15420,
    averageContextSize: '2.3KB',
    cacheHitRate: '78%'
  },
  quality: {
    relevanceScore: 8.7,
    completenessScore: 9.1,
    efficiencyScore: 8.3
  },
  performance: {
    averageProcessingTime: '45ms',
    memoryUsage: '1.2GB',
    successRate: '94%'
  }
};