context-engineering

context-engineering

한국어

A Claude Code plugin that systematically prepares AI context through a 7-phase pipeline — deciding what information to include, in what structure, at what level of compression.

When / How / How Much

Question	Answer
When	Information comes from 2+ sources, or a simple copy-paste would cause the AI to miss context
How	Run /context-engineering → answer 3 questions → the 7-phase pipeline handles the rest. Jump directly to a sub-skill if prior phases are already done
How Much	Compression scales with input size — see the Token Budget table below

Decision Table

Level 1: Do I need Context Engineering?

Situation	Use CE?	Reason
Single question, no extra context needed	No	A plain prompt is enough
Editing one file with a clear scope	No	Direct instruction is faster
Combining information from 2+ sources	Yes	AI will miss context without it
Need to reference previous decisions	Yes	KB retrieval keeps things consistent
Starting a project (CLAUDE.md + spec)	Yes	Format C generates all project artifacts
Writing the same type of prompt repeatedly	Yes	Format A produces a reusable instruction
Accumulating domain knowledge	Yes	Format B saves a KB entry

Level 2: Where do I enter?

Scenario	Entry point	Prerequisite
Starting from scratch	/context-engineering	—
Re-running gather only	:gather	—
Phase 1/3 artifacts already exist	:build	gather output required
Compressed context block exists	:compose	build output required
Re-validating existing output	:verify	compose output required
KB housekeeping	:verify --consolidate	Maintenance mode (independent of pipeline)

Each sub-skill checks for its prerequisite artifacts and exits with guidance if they are missing.

Level 3: What context to prioritize?

Once you know which sub-skill to enter, decide what context sources take priority for your task type:

Task type	Priority context	De-prioritize	Output
Q&A / factual answer	Retrieval-heavy: KB entries, source evidence, authoritative docs	Conversation history, speculative notes	— (direct answer)
Project setup	Architecture principles, CLAUDE.md policy, spec template, implementation plan	Unrelated KB entries	C
Knowledge base entry	Consolidation check, duplicate detection, stale entry check	Raw source text (already distilled)	B
Execution instruction	Role, task, constraints, output format	Verbose background (compress in Phase 5)	A

This table guides Phase 2 source selection and Phase 5 compression priorities. See context-source-strategy.md for the underlying RAG / Memory / Tool Result / System Prompt classification.

Token Budget Allocation

Phase 5 compresses collected context to fit within a target token budget. Compression tier is determined by input size:

Scale	Word count	Target compression	Strategy
Small (single file / question)	< 500 words	None needed	Pass through as-is
Medium (module / feature)	500–2,000 words	≤ 50%	Summarize Notes → remove duplicates
Large (full project)	2,000+ words	≤ 30%	Remove Notes → condense Key Facts

Compression order (what gets cut first):

1. Notes section — summarized or removed
2. Key Facts — condensed where purpose allows
3. Constraints / Decisions — never compressed (preserved verbatim regardless of budget pressure)

For large sources (2,000+ words), Phase 5 uses progressive loading: scan headers first, then read only the sections relevant to Phase 1 purpose.

Highlights

Context Engineering is the practice of designing what goes into an LLM's context window — beyond writing a single good prompt, it decides what information to give AI, when, and in what structure. RAG, memory architecture, token budget management, and system prompt design all fall under this umbrella.

• 7-phase gated pipeline — each phase auto-evaluates criteria and passes or pauses for confirmation
• 4 modular sub-skills — enter the pipeline at any phase when prior phases are already complete
• 3 output formats auto-determined from your stated intent (execution instruction / KB entry / project artifacts)
• KB maintenance mode — --consolidate detects duplicate, stale, and orphaned entries
• Pure markdown — no runtime dependencies, no build step

Quick Start