agentleFS
alex-voloshin-devalex-voloshin-dev/ai-skills/.agents/skills/context-engineering/SKILL.md

context-engineering

Skill2 starsChanged 6 months agoMITView on GitHub

Context engineering knowledge base — context stack architecture (8-layer model), memory engineering (taxonomy, CRUD, conflict resolution, compression), agent harness patterns (init/continuation, state blobs, token budgeting, caching, failure modes), RAG pipeline design (chunking, packing, degradation signals), multi-agent orchestration (boundaries, payload schemas, fan-out patterns), production AI checklists (8 checklists), reference implementation templates (grounding envelope, untrusted wrapper, tool error envelope), privacy and compliance for AI systems. Use when designing AI agent systems, reviewing context quality, building RAG pipelines, implementing memory, planning multi-agent architectures, or preparing AI systems for production.

133 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use using-agent-skills, idea-refine and 10 more.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • LLl0k0laDSkill

    using-agent-skills

    Use when starting a session or when you need to discover which skill applies to the current task. This is the meta-skill that governs how all other skills are discovered and invoked.

    Also in 36 projects that use this

  • LLl0k0laDSkill

    idea-refine

    Refine ideas through structured divergent and convergent thinking. Use "idea-refine" or "ideate" to trigger.

    Also in 44 projects that use this

  • HK-hubSkill

    deprecation-and-migration

    Manages deprecation and migration. Use when removing old systems, APIs, or features. Use when migrating users from one implementation to another. Use when deciding whether to maintain or sunset existing code.

    Also in 40 projects that use this

  • MrCipherSmithSkill

    constraint-driven-development

    Use when a project needs a persistent, measurable quality bar — starting a project without documented standards, 'set up constraints', or when coverage/perf/a11y thresholds get re-debated per-PR. Produces CONSTRAINTS.md with enforceable numbers, ratchets, and a guard against silent weakening. NOT for throwaway prototypes or a one-off CI setup.

    Also in 14 projects that use this

  • HK-hubSkill

    source-driven-development

    Grounds every implementation decision in official documentation. Use when you want authoritative, source-cited code free from outdated patterns. Use when building with any framework or library where correctness matters.

    Also in 44 projects that use this

  • +6 more from LLl0k0laD
  • +1 more from HK-hub

The file

We split this skill into the rules it gives an agent

2 rules. 0 are common, 2 are distinctive, and 0 are very specific to this project.

  • 0

    Common

    Most of the 119 edited versions we read keep these.

  • 2

    Distinctive

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Rule: keep policy/instructions (Layers 1-2) separate from knowledge (Layer 5).

    line 72
  2. Distinctive:

    Treat context window as a finite resource with explicit budget per layer:

    line 84

“Common” is measured: kept by at least 6 in 10 of the 119 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Context Engineering

Context engineering is the discipline of systematically selecting, structuring, and delivering the smallest possible set of high-signal tokens that make a task plausibly solvable for an LLM — reliably, safely, and cost-effectively.

This skill provides actionable patterns, checklists, and templates for the full context pipeline — from first principles through production readiness.

When to Use

  • Designing context pipelines for AI agents (what enters the LLM context window, in what order)
  • Reviewing context quality and token efficiency of existing systems
  • Building RAG systems (retrieval pipeline, chunking, packing, grounding)
  • Implementing memory (session, working, long-term, organizational, tool-output)
  • Designing agent harness (init/continuation prompts, state management, token budgets, caching)
  • Multi-agent orchestration (context boundaries, payload schemas, fan-out merge)
  • Production readiness assessment for AI systems (8-checklist gate)
  • Privacy and compliance for AI features (multi-tenant isolation, consent, data residency)

When NOT to Use

  • Prompt technique selection and template patterns → use prompt-engineering skill
  • Security audit of individual prompts → use prompt-engineering skill → security-checklist.md
  • Non-AI software engineering tasks → use software-engineer role + stack-specific role
  • Infrastructure and deployment → use devops-engineer role

Context Engineering vs Prompt Engineering

These are complementary disciplines:

  • Prompt engineering = designing the instruction text (technique selection, template patterns, formatting, few-shot)
  • Context engineering = designing the full context PIPELINE (what enters the window, in what order, how it's managed across turns, how it degrades gracefully)

Context engineering is the system; prompt engineering is one layer within it.

Key Concepts

First Principles

  1. Attention is finite — curate, don't stuff. "More context" is not monotonically better
  2. Position effects — critical info at beginning and end ("lost-in-the-middle"). Models use tokens near the start and end more effectively than those buried in the middle
  3. High-signal tokens > high-volume tokens — compact, discriminative context beats verbose dumps
  4. Separation of concerns — policy, knowledge, examples, output contract in distinct layers. Enables independent swap, A/B testing, failure analysis
  5. Context is a pipeline — produced by a system (retrieval, ranking, summarization, memory, policy filters, schema enforcement), not concatenated strings

The Context Stack (8-Layer Architecture)

Ordered layers, top = highest priority. Higher layers override lower on conflict.

LayerWhat Goes HereDesign Notes
1. System policy & safetyNon-negotiable constraints, content policies, refusal rulesFirst in window — highest attention. Cacheable
2. Developer instructionsRole definitions, hard rules, reasoning protocols, conventionsMaps to: Codex package rules, role overlays, and AGENTS.md guidance
3. Tool contractsSchemas, descriptions, permissions, failure modes, retry policiesTool descriptions ARE prompts — optimize them
4. Runtime stateCurrent project context, AGENTS.md, active file, task state, structured state blobMaps to: Codex AGENTS.md files
5. Knowledge context (RAG)Retrieved documents, search results, file contentsMust be wrapped as untrusted data with grounding envelopes
6. MemorySession, working, long-term, organizational, tool-outputMust be scoped, filtered, and conflict-resolved
7. Examples (few-shot)Minimal, high-leverage exemplars aligned to output contractDynamic selection preferred; skip if schema suffices
8. Output contractJSON Schema, format instructions, constraints, error handlingEnd of context — recency bias helps compliance

Rule: keep policy/instructions (Layers 1-2) separate from knowledge (Layer 5). Mixing them is a root cause of prompt injection and "obedience confusion."

→ Full reference: context-stack-model.md

Cacheable Prefix Design

Layers 1-3 rarely change → group all static content at the beginning of the prompt to enable KV cache reuse. Append dynamic content (Layer 4-8) at the end. Never interleave static and dynamic blocks.

Track cache_prefix_ratio = cached_tokens / total_input_tokens (target > 0.3).

Token Budget Allocation

Treat context window as a finite resource with explicit budget per layer:

AllocationSuggested %Notes
System + rules + tools (L1-3)15-25%Stable, cacheable prefix
Runtime state (L4)5-10%Structured state blob
Knowledge / RAG (L5)30-40%Dynamic, highest signal variance
Memory (L6)10-15%Filtered, relevance-ranked
Examples (L7)0-10%Only when needed
Output contract (L8)5-10%Schema + error handling

Overflow strategy: truncate lowest-priority layers first (L7 → L6 → L5).

Resource Files

FileContentsGuide §§
context-stack-model.md8-layer architecture, layer design patterns, position effects, mapping to Codex assets§3
memory-engineering.mdMemory taxonomy, CRUD lifecycle, conflict handling, compression strategies§6
agent-harness-patterns.mdInit/continuation, state blobs, token budgets, caching, failure modes, streaming§7
rag-engineering.mdPipeline blueprint (7 stages), chunking, packing, degradation signals§5
multi-agent-patterns.mdContext boundaries, payload schemas, return contracts, fan-out, contamination§7.6, §14
production-checklists.mdAll 8 production readiness checklists§11
reference-templates.mdGrounding envelope, untrusted wrapper, structured output, tool error envelope§12
privacy-compliance-ai.mdMulti-tenant isolation, data controls, consent, regional compliance§9

Integration

  • Follows rules: prompt-engineer role (prompt-level techniques, security, eval-first quality)
  • Used by workflows: ai-skills skill (context engineering validation), feature-dev skill (AI features), plan skill (AI work packages), code-review skill (context quality review)
  • Companion skill: prompt-engineering skill (technique selection, template patterns, eval, security checklist)
  • Collaborates with roles: solution-architect role (AI system design), product-manager role (agent contracts), sre-engineer role (context observability), software-engineer role (implementation)
  • Primary source: guides/context_engineering_guide.md

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.