SKILL: Extract Context from Output
Purpose
Analyze LLM outputs to extract patterns, constraints, and success indicators that can improve subsequent iterations.
Description
Uses a 7-phase extraction framework to pull structured context from any LLM output:
- Domain primitives: Objects, operations, relationships
- Patterns: Identified techniques and approaches
- Constraints: Hard requirements, preferences, anti-patterns
- Complexity factors: What makes this task challenging
- Success indicators: What's working well
- Error patterns: Potential failure modes
- Improvements needed: Gaps to address in next iteration
Usage
/extract-context <output-file>
# or
/extract-context --paste # Then paste output
Output Format
<context iteration="1" task="implement binary search">
<domain_primitives>
<objects>array, index, target, midpoint, bounds</objects>
<operations>search, compare, divide, return</operations>
<relationships>binary division, pointer adjustment, convergence</relationships>
</domain_primitives>
<patterns>
<pattern confidence="0.95">Two-pointer technique for O(log n)</pattern>
<pattern confidence="0.90">Guard clause pattern for edge cases</pattern>
<pattern confidence="0.85">Overflow-safe midpoint calculation</pattern>
</patterns>
<constraints>
<hard_requirement>Array must be sorted (ascending)</hard_requirement>
<hard_requirement>Handle empty array case</hard_requirement>
<hard_requirement>Return -1 if not found</hard_requirement>
<soft_preference>Use type hints for clarity</soft_preference>
<soft_preference>Include docstring with examples</soft_preference>
<anti_pattern>Linear search (defeats purpose)</anti_pattern>
<anti_pattern>Integer overflow on mid calculation</anti_pattern>
</constraints>
<complexity_factors>
<factor>Edge case handling (empty, single element, not found)</factor>
<factor>Integer overflow prevention</factor>
<factor>Off-by-one errors in bounds</factor>
</complexity_factors>
<success_indicators>
<indicator>O(log n) time complexity achieved</indicator>
<indicator>Handles empty array correctly</indicator>
<indicator>Comprehensive docstring included</indicator>
<indicator>Type validation present</indicator>
</success_indicators>
<error_patterns>
<error>Fails on unsorted input (silent wrong answer)</error>
<error>Does not handle duplicate values specially</error>
</error_patterns>
<improvements_needed priority="high">
<improvement>Add input validation for list type</improvement>
<improvement>Consider returning all indices for duplicates</improvement>
<improvement>Add usage examples in docstring</improvement>
</improvements_needed>
</context>
How It Works
- Send to LLM with structured extraction prompt
- Parse JSON response from LLM
- Fallback to heuristics if JSON parsing fails:
- Regex for code patterns (function defs, classes)
- Keyword detection for constraints
- Error keyword scanning
- Merge results from LLM + heuristics
- Return structured context for next iteration
Extraction Prompt
Analyze this agent output and extract structured context.
OUTPUT:
{agent_output}
TASK:
{original_task}
Extract and return as JSON:
{
"domain_primitives": {"objects": [], "operations": [], "relationships": []},
"patterns": [],
"constraints": {"hard_requirements": [], "soft_preferences": [], "anti_patterns": []},
"complexity_factors": [],
"success_indicators": [],
"error_patterns": []
}
Examples
Example 1: Extracting from Code Output
$ /extract-context ./prompts/001-palindrome/output.md
Input (LLM output):
def is_palindrome(s):
"""Check if string is palindrome."""
if not isinstance(s, str):
raise TypeError("Input must be string")
cleaned = ''.join(c.lower() for c in s if c.isalnum())
return cleaned == cleaned[::-1]
Output:
<context>
<patterns>
<pattern>String reversal comparison</pattern>
<pattern>Type validation with guard clause</pattern>
<pattern>Character filtering for alphanumeric only</pattern>
</patterns>
<constraints>
<hard_requirement>Input must be string type</hard_requirement>
<soft_preference>Case-insensitive comparison</soft_preference>
<soft_preference>Ignore non-alphanumeric characters</soft_preference>
</constraints>
<success_indicators>
<indicator>Handles non-string input with clear error</indicator>
<indicator>Normalizes case for comparison</indicator>
</success_indicators>
<improvements_needed>
<improvement>Add docstring examples</improvement>
<improvement>Consider two-pointer approach for efficiency</improvement>
</improvements_needed>
</context>
Example 2: Extracting from Design Output
$ /extract-context ./prompts/001-rate-limiter/output.md
Output:
<context>
<domain_primitives>
<objects>token bucket, request counter, time window</objects>
<operations>increment, check, reset, distribute</operations>
<relationships>bucket per client, distributed sync</relationships>
</domain_primitives>
<patterns>
<pattern>Token bucket algorithm</pattern>
<pattern>Sliding window for burst handling</pattern>
<pattern>Redis atomic operations for distribution</pattern>
</patterns>
<constraints>
<hard_requirement>100k req/s throughput</hard_requirement>
<hard_requirement>Sub-millisecond latency</hard_requirement>
<anti_pattern>Single point of failure</anti_pattern>
</constraints>
<improvements_needed>
<improvement>Add circuit breaker for Redis failures</improvement>
<improvement>Design multi-region replication</improvement>
</improvements_needed>
</context>
When to Use
Use when:
- After completing first iteration
- Preparing improved prompt for iteration 2+
- Identifying gaps before final review
- Building context for handoff to another agent
Don't use when:
- Output is trivial (nothing to extract)
- Already have clear requirements
- Final iteration (no more improvements planned)
Integration
Chain with other skills:
# Extract then improve
$ /extract-context output.md | /meta-prompt-iterate "task" --context -
# Build context over multiple iterations
$ /extract-context iter1.md >> context.xml
$ /extract-context iter2.md >> context.xml
# Feed into assessment
$ /extract-context output.md && /assess-quality --output output.md
Feeding Context to Next Iteration
The extracted context is automatically formatted into the next prompt:
## Previous Iteration Context
Based on iteration 1, incorporate these learnings:
**Patterns that worked:**
- Two-pointer technique (efficient)
- Guard clause pattern (robust)
**Must satisfy:**
- Array must be sorted
- Handle empty array case
**Improvements needed:**
- Add input validation
- Include usage examples
Now improve the solution...
Implementation
Uses ContextExtractor from the meta-prompting engine:
from meta_prompting_engine.extraction import ContextExtractor
from meta_prompting_engine.llm_clients.claude import ClaudeClient
llm = ClaudeClient(api_key="...")
extractor = ContextExtractor(llm)
context = extractor.extract_context_hierarchy(
agent_output="def binary_search...",
task="implement binary search"
)
print(f"Patterns: {context.patterns}")
print(f"Constraints: {context.constraints}")
print(f"Improvements: {context.improvements_needed}")
Source
- Engine:
/meta_prompting_engine/extraction.py - Tests:
/tests/test_core_engine.py - Real examples:
/test_real_api.pyoutput
