context-engineering

# Context Engineering ## Overview This skill enables Claude to manage context as an engineered system instead of treating prompts as isolated interactions. The workflow focuses on: - structured context management - memory organization - prompt layering - task decomposition - context compression - workflow continuity - multi-agent coordination - long-term reasoning systems The goal is to improve: - reasoning quality - execution consistency - scalability - workflow clarity - long-context reliability Instead of overwhelming Claude with raw information, context should be: - structured - prioritized - layered - actively maintained Good context engineering dramatically improves AI execution quality across large and complex workflows. --- # Setup Before starting: 1. Create a structured workspace. Recommended structure: ```plaintext context/ memory/ tasks/ planning/ reviews/ ``` 2. Create foundational files: ```plaintext project-summary.md active-context.md tasks.md architecture.md ``` 3. Define: - project goals - active workflows - important constraints - long-term objectives Recommended tools: - Claude - GitHub - Markdown files - Notion - Obsidian - MCP-compatible systems Optional: - Vector databases - Embedding search - Multi-agent orchestration - Memory indexing systems --- # Inputs Required - Project information - Workflow objectives - Existing documentation - Active tasks - Long-term goals Optional: - Architecture diagrams - Session history - Agent memory systems - Repository summaries --- # When to Use This Skill Use this skill when: - managing large projects - coordinating AI workflows - scaling multi-agent systems - handling long-running tasks - maintaining execution continuity - improving reasoning consistency - organizing large context windows - building advanced Claude workflows --- # When NOT to Use Do NOT use this skill for: - tiny one-step tasks - disposable prompts - isolated experiments - workflows with no continuity requirements --- # Example Use Case > Maintain structured context across a large AI engineering repository with multiple active workflows. Claude should: 1. Organize project memory 2. Compress unimportant context 3. Prioritize active information 4. Track architecture decisions 5. Maintain workflow continuity 6. Coordinate agent responsibilities 7. Refine context structure continuously Final result should: - improve reasoning quality - reduce context chaos - scale large workflows effectively - preserve long-term continuity - improve execution consistency --- # Core Context Engineering Principles ## 1. Context Is a System, Not a Prompt Good AI workflows depend on: - structured context - organized memory - prioritized information - active context management Claude should treat context as: - dynamic - layered - continuously maintained Avoid: - giant unstructured prompts - duplicated information - noisy context accumulation Structured systems improve: - reasoning - scalability - execution quality --- ## 2. Prioritize High-Value Context Not all information matters equally. Claude should prioritize: - active tasks - constraints - architecture decisions - workflow goals - unresolved blockers Avoid storing: - irrelevant history - duplicated summaries - low-value conversation filler Good prioritization improves: - context efficiency - reasoning quality - workflow clarity --- ## 3. Separate Long-Term & Active Context Context should be layered. Recommended structure: ```plaintext Long-Term Memory ↓ Project Context ↓ Active Workflow Context ↓ Immediate Task Context ``` This improves: - scalability - retrieval quality - reasoning focus Claude should avoid mixing: - permanent knowledge - temporary execution state - low-priority details --- ## 4. Compress Context Aggressively Large workflows require compression. Claude should: - summarize repeatedly - merge duplicate information - reduce unnecessary verbosity - preserve only important insights Compression improves: - scalability - reasoning efficiency - long-context reliability Good summaries preserve: - meaning - decisions - workflow continuity --- ## 5. Context Should Improve Execution The purpose of context engineering is execution quality. Good context systems improve: - planning - reasoning - implementation consistency - workflow continuity - multi-agent coordination Claude should actively use context to: - reduce repeated explanations - maintain alignment - improve long-term execution --- # Workflow ## 1. Define Core Project Context Start by identifying: - project goals - architecture - active workflows - constraints - long-term objectives Create foundational summaries for: - project overview - current state - active priorities Keep summaries: - concise - structured - easy to update --- ## 2. Organize Context Layers Separate: - permanent memory - project context - active tasks - temporary execution state Recommended structure: ```plaintext memory/ active-context/ planning/ reviews/ ``` This improves: - reasoning clarity - workflow scalability - retrieval quality --- ## 3. Compress Information Continuously Claude should: - summarize sessions - remove redundancy - preserve key decisions - simplify workflow history Avoid: - giant raw transcripts - duplicated notes - noisy context accumulation Good compression improves: - long-term usability - context efficiency - reasoning quality --- ## 4. Track Active Workflows Maintain: - active tasks - blockers - dependencies - implementation status - review feedback Claude should continuously update: - progress summaries - workflow priorities - pending execution steps This improves: - continuity - planning - coordination --- ## 5. Coordinate Multi-Agent Systems In multi-agent workflows: - agents require shared context - memory must remain synchronized - responsibilities should stay clear Claude should: - preserve coordination state - reduce duplicated effort - maintain shared understanding Good coordination improves: - scalability - execution quality - workflow stability --- ## 6. Refine Context Structure As projects grow: - simplify context systems - reorganize summaries - archive outdated information - optimize retrieval structures Context systems should evolve continuously. Avoid: - static memory dumps - uncontrolled context growth - fragmented organization --- ## 7. Validate Context Quality Before finalizing: - ensure summaries remain useful - remove stale information - verify workflow clarity - reduce unnecessary complexity Good context systems should feel: - lightweight - structured - scalable - execution-focused --- # Output Expectations The final output should include: - structured context systems - layered memory organization - compressed workflow summaries - scalable context architecture - execution-focused memory pipelines - maintainable long-term reasoning systems The workflow itself should remain: - lightweight - organized - scalable - adaptable - execution-oriented --- # Execution Strategy (for AI agents) The agent should: 1. Treat context as an engineered system 2. Prioritize high-value information aggressively 3. Compress workflows continuously 4. Maintain layered context organization 5. Coordinate memory across workflows carefully 6. Optimize for long-term execution quality The workflow should optimize for: - reasoning clarity - scalability - execution consistency - workflow continuity - long-context reliability --- # Best Practices - Keep context structured - Compress aggressively - Prioritize active information - Separate long-term and temporary context - Maintain lightweight summaries - Archive outdated information - Continuously refine memory organization --- # Notes - Context quality strongly affects AI execution quality - Compression is essential for scalable workflows - Layered memory systems improve reasoning consistency - Structured context dramatically improves multi-agent coordination - The best context systems remain lightweight and continuously maintained