context-engineering | meta | ClaudePluginHub

Skill

Community

context-engineering

0

Description

Master context engineering for AI agent systems. Use when designing agent architectures, debugging context failures, optimizing token usage, implementing memory systems, building multi-agent coordination, evaluating agent performance, or developing LLM-powered pipelines. Covers context fundamentals, degradation patterns, optimization techniques (compaction, masking, caching), compression strategies, memory architectures, multi-agent patterns, LLM-as-Judge evaluation, tool design, and project development.

Install

1

Add the repository(one-time)

$

/plugin marketplace add GGPrompts/TabzBeads

2

Install the plugin

$

/plugin install meta@tabz-beads

Tool Access

This skill inherits all available tools. When active, it can use any tool Claude has access to.

Supporting Assets

View in Repository

references/context-compression.md

references/context-degradation.md

references/context-fundamentals.md

references/context-optimization.md

references/evaluation.md

references/memory-systems.md

references/multi-agent-patterns.md

references/project-development.md

references/tool-design.md

scripts/compression_evaluator.py

scripts/context_analyzer.py

Skill Content

Context Engineering

Context engineering curates the smallest high-signal token set for LLM tasks. The goal: maximize reasoning quality while minimizing token usage.

When to Activate

Designing/debugging agent systems
Context limits constrain performance
Optimizing cost/latency
Building multi-agent coordination
Implementing memory systems
Evaluating agent performance
Developing LLM-powered pipelines

Core Principles

Context quality > quantity - High-signal tokens beat exhaustive content
Attention is finite - U-shaped curve favors beginning/end positions
Progressive disclosure - Load information just-in-time
Isolation prevents degradation - Partition work across sub-agents
Measure before optimizing - Know your baseline

Quick Reference

Topic	When to Use	Reference
Fundamentals	Understanding context anatomy, attention mechanics	context-fundamentals.md
Degradation	Debugging failures, lost-in-middle, poisoning	context-degradation.md
Optimization	Compaction, masking, caching, partitioning	context-optimization.md
Compression	Long sessions, summarization strategies	context-compression.md
Memory	Cross-session persistence, knowledge graphs	memory-systems.md
Multi-Agent	Coordination patterns, context isolation	multi-agent-patterns.md
Evaluation	Testing agents, LLM-as-Judge, metrics	evaluation.md
Tool Design	Tool consolidation, description engineering	tool-design.md
Pipelines	Project development, batch processing	project-development.md

Key Metrics

Token utilization: Warning at 70%, trigger optimization at 80%
Token variance: Explains 80% of agent performance variance
Multi-agent cost: ~15x single agent baseline
Compaction target: 50-70% reduction, <5% quality loss
Cache hit target: 70%+ for stable workloads

Four-Bucket Strategy

Write: Save context externally (scratchpads, files)
Select: Pull only relevant context (retrieval, filtering)
Compress: Reduce tokens while preserving info (summarization)
Isolate: Split across sub-agents (partitioning)

Anti-Patterns

Exhaustive context over curated context
Critical info in middle positions
No compaction triggers before limits
Single agent for parallelizable tasks
Tools without clear descriptions

Guidelines

Place critical info at beginning/end of context
Implement compaction at 70-80% utilization
Use sub-agents for context isolation, not role-play
Design tools with 4-question framework (what, when, inputs, returns)
Optimize for tokens-per-task, not tokens-per-request
Validate with probe-based evaluation
Monitor KV-cache hit rates in production
Start minimal, add complexity only when proven necessary

Scripts

context_analyzer.py - Context health analysis, degradation detection
compression_evaluator.py - Compression quality evaluation

Links

GitHub Stats

0 forks

Updated 22 hours ago

Similar Skills

Command Development

This skill should be used when the user asks to "create a slash command", "add a command", "write a custom command", "define command arguments", "use command frontmatter", "organize commands", "create command with file references", "interactive command", "use AskUserQuestion in command", or needs guidance on slash command structure, YAML frontmatter fields, dynamic arguments, bash execution in commands, user interaction patterns, or command development best practices for Claude Code.

54.7k

Agent Development

This skill should be used when the user asks to "create an agent", "add an agent", "write a subagent", "agent frontmatter", "when to use description", "agent examples", "agent tools", "agent colors", "autonomous agent", or needs guidance on agent structure, system prompts, triggering conditions, or agent development best practices for Claude Code plugins.

54.7k

Hook Development

This skill should be used when the user asks to "create a hook", "add a PreToolUse/PostToolUse/Stop hook", "validate tool use", "implement prompt-based hooks", "use ${CLAUDE_PLUGIN_ROOT}", "set up event-driven automation", "block dangerous commands", or mentions hook events (PreToolUse, PostToolUse, Stop, SubagentStop, SessionStart, SessionEnd, UserPromptSubmit, PreCompact, Notification). Provides comprehensive guidance for creating and implementing Claude Code plugin hooks with focus on advanced prompt-based hooks API.

54.7k