Context Engineering Mastery

Master the art of prompt engineering and context optimization for AI systems. This comprehensive course covers everything from fundamental concepts to production-ready implementations, with hands-on exercises and real-world case studies.

Prerequisites & Setup

# Quick Setup Commands
npm init -y
npm install openai axios dotenv
echo "OPENAI_API_KEY=your_key_here" > .env
echo ".env" > .gitignore
      

Module 1: Context Fundamentals

Understanding Context Windows

Context windows are the foundation of how AI models process information. Think of the context window as the model's "working memory" - it can only see and process a limited amount of text at once. Understanding this limitation is crucial for effective prompt engineering.

Practical Token Estimation

// Advanced token estimation with multiple model support
class TokenEstimator {
  static models = {
    'gpt-4': { ratio: 4, overhead: 1.1 },
    'claude-3': { ratio: 3.8, overhead: 1.05 },
    'gemini-pro': { ratio: 4.2, overhead: 1.15 }
  };

  static estimate(text, model = 'gpt-4') {
    const config = this.models[model];
    const baseTokens = Math.ceil(text.length / config.ratio);
    return Math.ceil(baseTokens * config.overhead);
  }

  static optimizeForLimit(text, limit, model = 'gpt-4') {
    const estimated = this.estimate(text, model);
    if (estimated <= limit) return text;
    
    // Smart truncation preserving important sections
    const ratio = limit / estimated;
    const targetLength = Math.floor(text.length * ratio * 0.9); // 10% buffer
    
    return this.smartTruncate(text, targetLength);
  }

  static smartTruncate(text, maxLength) {
    if (text.length <= maxLength) return text;
    
    // Preserve beginning and end, truncate middle
    const keep = Math.floor(maxLength * 0.4);
    const start = text.substring(0, keep);
    const end = text.substring(text.length - keep);
    
    return start + '\n\n[... content truncated ...]\n\n' + end;
  }
}

// Usage example
const longDocument = "Your long document here...";
const optimized = TokenEstimator.optimizeForLimit(longDocument, 4000, 'gpt-4');
console.log(`Estimated tokens: ${TokenEstimator.estimate(optimized)}`);
      

Token Management & Optimization

Effective token management goes beyond simple counting. It involves strategic decisions about what content to include, how to structure it, and when to apply compression techniques. This lesson covers advanced strategies for maximizing the value of every token in your context window.

Advanced Token Management Patterns

class ContextManager {
  constructor(maxTokens = 4000) {
    this.maxTokens = maxTokens;
    this.reservedTokens = 500; // For response
    this.availableTokens = maxTokens - this.reservedTokens;
    this.contexts = new Map();
    this.priorities = new Map();
  }

  addContext(key, content, priority = 1, persistent = false) {
    const tokens = TokenEstimator.estimate(content);
    this.contexts.set(key, { content, tokens, priority, persistent });
    this.priorities.set(key, priority);
  }

  buildOptimalContext(taskContext = '') {
    let result = taskContext;
    let usedTokens = TokenEstimator.estimate(taskContext);

    // Sort by priority (higher = more important)
    const sortedContexts = Array.from(this.contexts.entries())
      .sort(([,a], [,b]) => b.priority - a.priority);

    for (const [key, context] of sortedContexts) {
      if (usedTokens + context.tokens <= this.availableTokens) {
        result += '\n\n' + context.content;
        usedTokens += context.tokens;
      } else if (!context.persistent) {
        // Try to fit a compressed version
        const compressed = this.compressContext(context.content, 
          this.availableTokens - usedTokens);
        if (compressed) {
          result += '\n\n' + compressed;
          usedTokens += TokenEstimator.estimate(compressed);
        }
      }
    }

    return result;
  }

  compressContext(content, maxTokens) {
    if (TokenEstimator.estimate(content) <= maxTokens) return content;
    
    // Extract key information
    const lines = content.split('\n');
    const important = lines.filter(line => 
      line.includes('Error:') || 
      line.includes('Warning:') || 
      line.includes('TODO:') ||
      line.match(/^#+s/) // Headers
    );

    const compressed = important.join('\n');
    return TokenEstimator.estimate(compressed) <= maxTokens ? compressed : null;
  }
}

// Usage example
const contextMgr = new ContextManager(8000);
contextMgr.addContext('system', 'You are a helpful assistant...', 10, true);
contextMgr.addContext('history', 'Previous conversation...', 3);
contextMgr.addContext('docs', 'Relevant documentation...', 7);

const optimizedPrompt = contextMgr.buildOptimalContext('User: How do I fix this error?');
      

Context Architecture Patterns

Beyond individual optimization techniques, successful context engineering requires architectural thinking. This lesson introduces proven patterns for structuring context at scale, designing reusable templates, and building maintainable prompt systems.

System Instructions (High Priority)
├── Core Behavior Guidelines
├── Output Format Requirements
└── Safety & Constraint Rules

Task Context (Medium Priority)  
├── Current Objective
├── Relevant Examples
└── Success Criteria

Supporting Context (Low Priority)
├── Background Information
├── Historical Data
└── Reference Materials
          

BaseTemplate
├── System Prompt
├── Common Instructions
└── Error Handling

SpecializedTemplate extends BaseTemplate
├── Domain-Specific Rules
├── Custom Examples
└── Specialized Formatting

TaskTemplate extends SpecializedTemplate
├── Task-Specific Context
├── Current Parameters
└── Dynamic Content
          

Implementation: Modular Context System

class ContextArchitect {
  constructor() {
    this.templates = new Map();
    this.modules = new Map();
    this.inheritance = new Map();
  }

  // Define reusable context modules
  defineModule(name, content, metadata = {}) {
    this.modules.set(name, {
      content: typeof content === 'function' ? content : () => content,
      priority: metadata.priority || 5,
      required: metadata.required || false,
      conditions: metadata.conditions || [],
      maxTokens: metadata.maxTokens || null
    });
  }

  // Create template inheritance chains
  defineTemplate(name, extends_template = null, modules = []) {
    this.templates.set(name, { extends_template, modules });
    if (extends_template) {
      this.inheritance.set(name, extends_template);
    }
  }

  // Build context with inheritance and module composition
  buildContext(templateName, variables = {}, options = {}) {
    const context = [];
    const usedModules = new Set();
    
    // Collect all modules through inheritance chain
    const allModules = this.collectModules(templateName);
    
    // Sort by priority and apply conditions
    const applicableModules = allModules
      .filter(module => this.evaluateConditions(module.conditions, variables))
      .sort((a, b) => b.priority - a.priority);

    let tokenCount = 0;
    const maxTokens = options.maxTokens || 4000;

    for (const module of applicableModules) {
      const content = module.content(variables);
      const tokens = TokenEstimator.estimate(content);
      
      if (tokenCount + tokens <= maxTokens || module.required) {
        context.push(content);
        tokenCount += tokens;
        usedModules.add(module.name);
      }
    }

    return {
      content: context.join('\n\n'),
      metadata: {
        totalTokens: tokenCount,
        usedModules: Array.from(usedModules),
        truncated: applicableModules.length > usedModules.size
      }
    };
  }

  collectModules(templateName) {
    const modules = [];
    const template = this.templates.get(templateName);
    
    if (!template) return modules;

    // Recursively collect from parent templates
    if (template.extends_template) {
      modules.push(...this.collectModules(template.extends_template));
    }

    // Add modules from current template
    for (const moduleName of template.modules) {
      const module = this.modules.get(moduleName);
      if (module) {
        modules.push({ name: moduleName, ...module });
      }
    }

    return modules;
  }

  evaluateConditions(conditions, variables) {
    return conditions.every(condition => {
      if (typeof condition === 'function') {
        return condition(variables);
      }
      if (typeof condition === 'string') {
        return variables[condition] !== undefined;
      }
      return true;
    });
  }
}

// Usage example
const architect = new ContextArchitect();

// Define reusable modules
architect.defineModule('system_base', 
  () => 'You are a professional AI assistant. Always be helpful, accurate, and concise.',
  { priority: 10, required: true });

architect.defineModule('code_expert',
  (vars) => `You are an expert in ${vars.language || 'programming'}. Focus on best practices and clean code.`,
  { priority: 9, conditions: ['language'] });

architect.defineModule('error_context',
  (vars) => `Current error: ${vars.error}\nStack trace: ${vars.stackTrace}`,
  { priority: 8, conditions: [(v) => v.error] });

// Define template inheritance
architect.defineTemplate('base', null, ['system_base']);
architect.defineTemplate('coding', 'base', ['code_expert']);
architect.defineTemplate('debugging', 'coding', ['error_context']);

// Build context for debugging session
const result = architect.buildContext('debugging', {
  language: 'JavaScript',
  error: 'TypeError: Cannot read property of undefined',
  stackTrace: 'at line 42 in main.js'
});

console.log(result.content);
console.log(`Used ${result.metadata.totalTokens} tokens`);
      

🛠️ Hands-on Exercise 1: Context Optimization Challenge

// Starter template - extend this for your solution
class CodebaseContextOptimizer {
  constructor(config = {}) {
    this.maxTokens = config.maxTokens || 8000;
    this.model = config.model || 'gpt-4';
    this.dependencies = new Map(); // file -> [dependencies]
    this.importance = new Map();   // file -> importance score
    this.cache = new Map();        // optimized contexts
  }

  // TODO: Implement these methods
  async analyzeCodebase(files) {
    // Build dependency graph and importance scores
  }

  optimizeForReview(targetFile, reviewType = 'general') {
    // Create optimized context for specific review
  }

  // HINT: Consider these factors for importance scoring:
  // - File size and complexity
  // - Number of dependencies/dependents  
  // - Recent changes (git history)
  // - Error frequency (if available)
  // - Test coverage
}

// Test your implementation with:
const optimizer = new CodebaseContextOptimizer({ maxTokens: 8000 });
// Add your test cases here
        

Module 2: Advanced Prompt Engineering

Prompt Structure & Design Patterns

Professional prompt engineering goes far beyond simple instructions. This lesson covers proven structural patterns that consistently produce high-quality results across different models and use cases.

Advanced Structural Patterns

class PromptArchitect {
  static patterns = {
    // Chain of Responsibility Pattern
    chainOfResponsibility: (steps) => `
Let's work through this systematically:

${steps.map((step, i) => `
Step ${i + 1}: ${step.title}
- Objective: ${step.objective}
- Method: ${step.method}
- Expected Output: ${step.output}
`).join('\n')}

Begin with Step 1 and proceed sequentially.
    `,

    // Template Method Pattern  
    templateMethod: (template, variables) => {
      return template.replace(/{{(w+)}}/g, (match, key) => {
        return variables[key] || `[MISSING: ${key}]`;
      });
    },

    // Strategy Pattern for different approaches
    strategyPattern: (strategies, context) => `
Given the context: ${context}

Consider these approaches:
${strategies.map((strategy, i) => `
Approach ${i + 1}: ${strategy.name}
- Pros: ${strategy.pros.join(', ')}
- Cons: ${strategy.cons.join(', ')}
- Best for: ${strategy.bestFor}
`).join('\n')}

Select the most appropriate approach and explain your reasoning.
    `,

    // Observer Pattern for multi-perspective analysis
    observerPattern: (perspectives, subject) => `
Analyze "${subject}" from multiple perspectives:

${perspectives.map(p => `
From the ${p.role} perspective:
- Key concerns: ${p.concerns.join(', ')}
- Success metrics: ${p.metrics.join(', ')}
- Potential issues: ${p.issues.join(', ')}
`).join('\n')}

Synthesize insights and provide balanced recommendations.
    `
  };

  static buildRoleBasedPrompt(role, expertise, context, task) {
    return `
You are a ${role} with ${expertise.length} years of experience in:
${expertise.map(skill => `- ${skill}`).join('\n')}

Context: ${context}

Your task: ${task}

Approach this with the mindset and methodology of an experienced professional.
Provide actionable insights that reflect industry best practices.
    `;
  }

  static buildConstrainedPrompt(constraints, task) {
    return `
Task: ${task}

Operating constraints:
${Object.entries(constraints).map(([key, value]) => `
- ${key}: ${value}
`).join('')}

Work within these limitations and explain any tradeoffs made.
    `;
  }
}

// Usage examples
const debuggingSteps = [
  {
    title: "Problem Identification",
    objective: "Isolate the root cause",
    method: "Error analysis and log examination", 
    output: "Clear problem statement"
  },
  {
    title: "Solution Design",
    objective: "Design targeted fix",
    method: "Best practices research",
    output: "Implementation plan"
  }
];

const prompt = PromptArchitect.patterns.chainOfResponsibility(debuggingSteps);
      

Few-Shot & Zero-Shot Techniques

Few-shot and zero-shot learning represent the cutting edge of prompt engineering. These techniques allow you to achieve high performance with minimal training data by leveraging the model's existing knowledge and reasoning capabilities.

Advanced Few-Shot Implementation

class FewShotEngine {
  constructor(config = {}) {
    this.maxExamples = config.maxExamples || 5;
    this.similarityThreshold = config.similarityThreshold || 0.8;
    this.examples = [];
    this.embedding = config.embeddingFunction || this.defaultEmbedding;
  }

  // Add training examples with metadata
  addExample(input, output, metadata = {}) {
    this.examples.push({
      input,
      output,
      metadata,
      embedding: this.embedding(input),
      created: Date.now()
    });
  }

  // Select most relevant examples for given input
  selectExamples(input, taskType = 'general') {
    const inputEmbedding = this.embedding(input);
    
    // Score examples by relevance
    const scored = this.examples.map(example => ({
      ...example,
      score: this.calculateRelevance(inputEmbedding, example, taskType)
    }));

    // Filter and sort by relevance
    return scored
      .filter(ex => ex.score > this.similarityThreshold)
      .sort((a, b) => b.score - a.score)
      .slice(0, this.maxExamples);
  }

  calculateRelevance(inputEmbedding, example, taskType) {
    let score = this.cosineSimilarity(inputEmbedding, example.embedding);
    
    // Boost score for matching task types
    if (example.metadata.taskType === taskType) {
      score *= 1.2;
    }
    
    // Slight preference for recent examples
    const ageBonus = Math.max(0, 1 - (Date.now() - example.created) / (30 * 24 * 60 * 60 * 1000));
    score += ageBonus * 0.1;
    
    return score;
  }

  buildFewShotPrompt(input, taskType = 'general', basePrompt = '') {
    const selectedExamples = this.selectExamples(input, taskType);
    
    if (selectedExamples.length === 0) {
      return `${basePrompt}\n\nInput: ${input}\nOutput:`;
    }

    const exampleText = selectedExamples.map(ex => 
      `Input: ${ex.input}\nOutput: ${ex.output}`
    ).join('\n\n');

    return `${basePrompt}

Here are some examples:

${exampleText}

Now apply the same pattern:

Input: ${input}
Output:`;
  }

  // Simple embedding simulation (use real embeddings in production)
  defaultEmbedding(text) {
    // This is a simplified embedding - use OpenAI embeddings or similar
    const words = text.toLowerCase().split(/\W+/);
    const vector = new Array(384).fill(0);
    
    words.forEach((word, i) => {
      const hash = this.simpleHash(word);
      vector[hash % 384] += 1;
    });
    
    return this.normalize(vector);
  }

  simpleHash(str) {
    let hash = 0;
    for (let i = 0; i < str.length; i++) {
      const char = str.charCodeAt(i);
      hash = ((hash << 5) - hash) + char;
      hash = hash & hash; // Convert to 32-bit integer
    }
    return Math.abs(hash);
  }

  normalize(vector) {
    const magnitude = Math.sqrt(vector.reduce((sum, val) => sum + val * val, 0));
    return magnitude > 0 ? vector.map(val => val / magnitude) : vector;
  }

  cosineSimilarity(a, b) {
    return a.reduce((sum, val, i) => sum + val * b[i], 0);
  }
}

// Usage example
const fewShot = new FewShotEngine({ maxExamples: 3 });

// Add examples for code review
fewShot.addExample(
  "function add(a, b) { return a + b; }",
  "✅ Clean and simple. Consider adding JSDoc: /** Adds two numbers */",
  { taskType: 'code-review', language: 'javascript' }
);

fewShot.addExample(
  "const result = data.map(x => x.value).filter(x => x > 0)",
  "✅ Good functional style. Consider variable naming: .filter(value => value > 0)",
  { taskType: 'code-review', language: 'javascript' }
);

// Generate prompt for new code review
const prompt = fewShot.buildFewShotPrompt(
  "async function fetchUser(id) { return await api.get('/users/' + id); }",
  'code-review',
  'Review this code for best practices and potential improvements:'
);
      

Chain-of-Thought & Reasoning

Chain-of-thought prompting represents a breakthrough in getting AI models to perform complex reasoning. By encouraging step-by-step thinking, we can dramatically improve accuracy on logical, mathematical, and analytical tasks.

Problem: Calculate 15% tip on $47.50 Let's think step by step: 1. Convert 15% to decimal: 0.15 2. Multiply: $47.50 × 0.15 = $7.125 3. Round to cents: $7.13

Problem: [Complex problem statement] Let's think step by step to solve this. [Model naturally breaks down reasoning]

Advanced Reasoning Patterns

class ReasoningEngine {
  static patterns = {
    // Progressive refinement
    progressiveRefinement: (problem, iterations = 3) => `
Problem: ${problem}

Let's solve this through progressive refinement:

Initial Analysis:
- Break down the problem into core components
- Identify key constraints and assumptions
- Outline potential solution approaches

${Array.from({length: iterations}, (_, i) => `
Iteration ${i + 1}:
- Refine understanding based on previous analysis
- Address any gaps or inconsistencies
- Improve solution quality and accuracy
`).join('\n')}

Final Solution:
- Synthesize insights from all iterations
- Provide clear, actionable recommendations
    `,

    // Devil's advocate reasoning
    devilsAdvocate: (claim) => `
Initial Position: ${claim}

Now let's challenge this systematically:

Supporting Evidence:
1. [List strongest supporting points]
2. [Include relevant data/examples]
3. [Consider expert opinions]

Counter-Arguments:
1. [Identify potential weaknesses]
2. [Consider alternative explanations]
3. [Examine contradictory evidence]

Synthesis:
- Weigh strengths vs weaknesses
- Identify areas of uncertainty
- Provide nuanced final assessment
    `,

    // Root cause analysis
    rootCauseAnalysis: (problem) => `
Problem Statement: ${problem}

5 Whys Analysis:
1. Why did this problem occur?
   Answer: [Initial cause]

2. Why did [initial cause] happen?
   Answer: [Deeper cause]

3. Why did [deeper cause] occur?
   Answer: [Root level cause]

4. Why did [root level cause] happen?
   Answer: [Systemic cause]

5. Why did [systemic cause] develop?
   Answer: [Fundamental root cause]

Fishbone Analysis:
- People factors: [Human-related causes]
- Process factors: [Workflow/procedure issues]
- Environment factors: [External conditions]
- Material factors: [Resource/tool problems]
- Method factors: [Approach/technique issues]
- Machine factors: [System/technology problems]

Action Plan:
1. Immediate fixes (address symptoms)
2. Short-term solutions (address proximate causes)
3. Long-term prevention (address root causes)
    `,

    // Scenario planning
    scenarioPlanning: (decision, factors) => `
Decision Context: ${decision}

Key Uncertainty Factors:
${factors.map(f => `- ${f.name}: ${f.range}`).join('\n')}

Scenario 1: Best Case
${factors.map(f => `- ${f.name}: ${f.best}`).join('\n')}
Implications: [Positive outcomes and opportunities]

Scenario 2: Most Likely
${factors.map(f => `- ${f.name}: ${f.likely}`).join('\n')}
Implications: [Expected outcomes and challenges]

Scenario 3: Worst Case  
${factors.map(f => `- ${f.name}: ${f.worst}`).join('\n')}
Implications: [Risks and mitigation strategies]

Robust Strategy:
- Actions that work well across all scenarios
- Contingency plans for each scenario
- Early warning indicators to monitor
    `
  };

  static buildSocraticPrompt(topic) {
    return `
Let's explore "${topic}" through Socratic questioning:

Level 1 - Clarification:
- What do you mean by "${topic}"?
- How would you define the key terms?
- Can you give me a specific example?

Level 2 - Assumptions:
- What assumptions are you making?
- What if we assumed the opposite?
- How might someone from a different culture view this?

Level 3 - Evidence and Reasoning:
- What evidence supports this view?
- How did you come to this conclusion?
- What might contradict this evidence?

Level 4 - Implications and Consequences:
- What are the implications of this?
- If this is true, what follows?
- How does this affect [related area]?

Level 5 - Meta-Questions:
- Why is this question important?
- What does this question assume?
- How does this relate to what we already know?

Work through each level systematically, building understanding progressively.
    `;
  }
}

// Usage example for complex debugging
const debugPrompt = ReasoningEngine.patterns.rootCauseAnalysis(
  "Application crashes randomly in production but works fine in development"
);

// Scenario planning for architecture decisions
const architectureScenarios = ReasoningEngine.patterns.scenarioPlanning(
  "Choose between microservices vs monolithic architecture",
  [
    { 
      name: "Team size", 
      range: "5-50 developers",
      best: "20+ experienced developers",
      likely: "10-15 mixed experience", 
      worst: "5-8 junior developers"
    },
    {
      name: "Scaling requirements",
      range: "1K-1M daily users", 
      best: "Predictable linear growth",
      likely: "Moderate spikes during events",
      worst: "Unpredictable viral growth"
    }
  ]
);
      

Prompt Templates & Frameworks

Creating reusable, maintainable prompt templates is essential for production AI systems. This lesson covers advanced templating techniques, version control strategies, and testing frameworks for prompts.

🛠️ Hands-on Exercise 2: Advanced Reasoning System

Module 3: Context Engineering for Code

Code Generation Strategies

Code generation with AI requires specialized context engineering techniques. Unlike general text, code has strict syntax requirements, complex dependencies, and specific quality standards that must be maintained.

Layer 1: Language & Framework Context
├── Syntax rules and conventions
├── Framework-specific patterns  
├── Version compatibility notes
└── Performance considerations

Layer 2: Project Context
├── Architecture overview
├── Coding standards
├── Dependency information
└── Design patterns in use

Layer 3: Local Context  
├── Current file/module scope
├── Related functions/classes
├── Import statements
└── Immediate dependencies

Layer 4: Task Context
├── Specific requirements
├── Expected inputs/outputs
├── Error handling needs
└── Testing requirements
          

Advanced Code Generation Engine

class CodeGenerationEngine {
  constructor(config = {}) {
    this.language = config.language || 'javascript';
    this.framework = config.framework || null;
    this.codeStyle = config.codeStyle || 'standard';
    this.contextLayers = new Map();
    this.templates = new Map();
    this.examples = new Map();
  }

  // Build comprehensive context for code generation
  buildCodeContext(task, options = {}) {
    const context = {
      language: this.getLanguageContext(),
      project: this.getProjectContext(options.projectPath),
      local: this.getLocalContext(options.currentFile),
      task: this.getTaskContext(task),
      examples: this.getRelevantExamples(task)
    };

    return this.combineContextLayers(context, options.maxTokens);
  }

  getLanguageContext() {
    const langTemplates = {
      javascript: `
Language: JavaScript (ES2022+)
Key principles:
- Use const/let, avoid var
- Prefer arrow functions for callbacks
- Use async/await over Promises.then()
- Implement proper error handling
- Follow functional programming patterns where appropriate

Common patterns:
- Destructuring: const {name, age} = user
- Template literals: \`Hello \${name}\`
- Optional chaining: user?.address?.street
- Nullish coalescing: value ?? defaultValue
      `,
      python: `
Language: Python 3.9+
Key principles:
- Follow PEP 8 style guidelines
- Use type hints for better clarity
- Implement proper exception handling
- Prefer list/dict comprehensions
- Use context managers for resources

Common patterns:
- f-strings: f"Hello {name}"
- Type hints: def func(name: str) -> bool:
- Context managers: with open(file) as f:
- Comprehensions: [x for x in items if condition]
      `,
      typescript: `
Language: TypeScript 4.5+
Key principles:
- Define interfaces for all data structures
- Use strict type checking
- Implement proper generic constraints
- Leverage utility types effectively
- Follow functional programming patterns

Common patterns:
- Interfaces: interface User { name: string; age: number; }
- Generics: function identity<T>(arg: T): T
- Union types: string | number | boolean
- Utility types: Partial<T>, Required<T>, Pick<T, K>
      `
    };

    return langTemplates[this.language] || 'Generic programming language context';
  }

  getProjectContext(projectPath) {
    if (!projectPath) return '';

    // In production, this would analyze the actual project
    return `
Project Structure Analysis:
- Architecture: ${this.detectArchitecture(projectPath)}
- Dependencies: ${this.getDependencies(projectPath)}
- Coding Standards: ${this.getCodingStandards(projectPath)}
- Testing Framework: ${this.getTestingFramework(projectPath)}

Design Patterns in Use:
- ${this.getDesignPatterns(projectPath).join('\n- ')}
    `;
  }

  getLocalContext(currentFile) {
    if (!currentFile) return '';

    return `
Current File Context:
- Module: ${currentFile.module}
- Imports: ${currentFile.imports.join(', ')}
- Exports: ${currentFile.exports.join(', ')}
- Related Functions: ${currentFile.relatedFunctions.join(', ')}

Local Variables in Scope:
${currentFile.variables.map(v => `- ${v.name}: ${v.type}`).join('\n')}
    `;
  }

  getTaskContext(task) {
    return `
Task: ${task.description}

Requirements:
${task.requirements.map(r => `- ${r}`).join('\n')}

Expected Input: ${task.input}
Expected Output: ${task.output}

Quality Criteria:
- Correctness: Code must work as specified
- Readability: Clear variable names and structure  
- Maintainability: Easy to modify and extend
- Performance: Efficient algorithms and data structures
- Testing: Include unit tests if requested

Error Handling:
- Validate inputs appropriately
- Handle edge cases gracefully
- Provide meaningful error messages
- Follow language-specific exception patterns
    `;
  }

  getRelevantExamples(task) {
    const examples = this.examples.get(task.type) || [];
    return examples.slice(0, 3).map(ex => `
Example:
\`\`\`${this.language}
// Task: ${ex.task}
${ex.code}
\`\`\`

Key Points:
${ex.keyPoints.map(p => `- ${p}`).join('\n')}
    `).join('\n\n');
  }

  // Generate complete code with context
  async generateCode(task, options = {}) {
    const context = this.buildCodeContext(task, options);
    
    const prompt = `
${context}

Now generate the requested code:

Requirements: ${task.description}

Please provide:
1. Clean, well-documented code
2. Appropriate error handling  
3. Unit tests (if applicable)
4. Usage examples
5. Brief explanation of approach

Code:
`;

    // In production, this would call your AI model
    return this.callAIModel(prompt);
  }

  // Add examples to improve generation quality
  addExample(type, task, code, keyPoints) {
    if (!this.examples.has(type)) {
      this.examples.set(type, []);
    }
    
    this.examples.get(type).push({
      task,
      code,
      keyPoints
    });
  }

  // Utility methods (would be implemented based on actual file analysis)
  detectArchitecture(path) { return 'MVC with service layer'; }
  getDependencies(path) { return ['express', 'lodash', 'moment']; }
  getCodingStandards(path) { return 'ESLint + Prettier'; }
  getTestingFramework(path) { return 'Jest'; }
  getDesignPatterns(path) { return ['Factory', 'Observer', 'Strategy']; }
}

// Usage example
const codeGen = new CodeGenerationEngine({
  language: 'javascript',
  framework: 'react',
  codeStyle: 'airbnb'
});

// Add training examples
codeGen.addExample('api-endpoint', 'Create user registration endpoint', `
app.post('/api/users/register', async (req, res) => {
  try {
    const { email, password, name } = req.body;
    
    // Validate input
    if (!email || !password || !name) {
      return res.status(400).json({ error: 'Missing required fields' });
    }
    
    // Check if user exists
    const existingUser = await User.findByEmail(email);
    if (existingUser) {
      return res.status(409).json({ error: 'User already exists' });
    }
    
    // Create user
    const user = await User.create({ email, password, name });
    
    res.status(201).json({ 
      message: 'User created successfully',
      userId: user.id 
    });
  } catch (error) {
    console.error('Registration error:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});
`, ['Input validation', 'Error handling', 'Async/await pattern', 'HTTP status codes']);

// Generate new endpoint
const task = {
  description: 'Create user profile update endpoint',
  requirements: [
    'Allow updating name and email',
    'Require authentication',
    'Validate input data',
    'Handle conflicts gracefully'
  ],
  input: 'PUT /api/users/profile with user data',
  output: 'Updated user profile or error',
  type: 'api-endpoint'
};

const generatedCode = await codeGen.generateCode(task, {
  projectPath: './src',
  currentFile: {
    module: 'userRoutes.js',
    imports: ['express', 'bcrypt', 'jwt'],
    exports: ['userRouter'],
    relatedFunctions: ['authenticateUser', 'validateUserData'],
    variables: [
      { name: 'router', type: 'express.Router' },
      { name: 'User', type: 'Model' }
    ]
  }
});
      

Code Review & Debugging Prompts

Automated code review and debugging with AI requires sophisticated prompt engineering that can understand code quality principles, identify potential issues, and provide actionable feedback.

Documentation & Testing Automation

Transform your development workflow by automating documentation generation and test creation through intelligent context engineering.

🛠️ Hands-on Exercise 3: AI Code Assistant

Module 4: Production-Ready Implementations

API Integration & Rate Limiting

Error Handling & Fallback Strategies

Performance Monitoring & Analytics

Security & Privacy Considerations

Module 5: Real-World Case Studies

Enterprise Content Generation

Customer Support Automation

Educational Content Creation

🎓 Capstone Project

🏆 Certification & Next Steps