사용 방법
- 설치 명령을 복사하고 자신의 에이전트 환경에 설치하기 전에 소스 패키지를 확인하세요.
- 필요한 도구, 인증 정보, 지원 환경은 원본 문서에서 확인하세요.
- 입력과 원하는 산출물을 설명하고 출처와 결과를 대조하세요.
npx skills add https://github.com/composio-community/opencode-skills --skill context-engineering시작 전 확인
- 설치에는 모델 구독, API 한도, 파일 접근 권한이 포함되지 않습니다.
- 별점 수와 설치 수는 활동 지표이며 독립적인 품질·보안 검증이 아닙니다.
원본 저장소의 제목, 예시, 코드, 표, 링크, 이미지를 유지해 표시합니다.
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:
- Create a structured workspace.
Recommended structure:
context/
memory/
tasks/
planning/
reviews/- Create foundational files:
project-summary.md
active-context.md
tasks.md
architecture.md- 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:
- Organize project memory
- Compress unimportant context
- Prioritize active information
- Track architecture decisions
- Maintain workflow continuity
- Coordinate agent responsibilities
- 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:
Long-Term Memory
↓
Project Context
↓
Active Workflow Context
↓
Immediate Task ContextThis 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:
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:
- Treat context as an engineered system
- Prioritize high-value information aggressively
- Compress workflows continuously
- Maintain layered context organization
- Coordinate memory across workflows carefully
- 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