oneryalcin/skills-pattern.md

## skills-pattern.md

      
    Raw
  

              skills-pattern.md
            
          
    Skills Pattern: Just-In-Time Context Injection for LLM Agents

Right. Focus on injection mechanics and why it works, not what skills exist.
Core Mechanics

1. Just-In-Time Context Injection

Not "here's all documentation upfront" - it's pull, not push:
Session starts → Minimal bootstrap injected
Agent encounters task → Agent searches for skill
Agent finds match → Agent reads SKILL.md
Agent uses skill → Follows instructions

Key: Context only loaded when needed. Main context stays clean.
2. SKILL.md Format = Executable Instructions

Not documentation. Not guidelines. Executable process:
---
name: Thing To Do
when_to_use: Specific trigger conditions
---

# Overview
Core principle in 1-2 sentences

# Quick Reference
Pattern matching

# Implementation
Step-by-step checklist

# Supporting files
Tools/scripts if needed
Why it works:

Frontmatter: Machine-parseable metadata
Checklist: Unambiguous steps (→ TodoWrite)
when_to_use: Clear trigger conditions
Markdown: LLM-native format, easy to read/write

3. Enforcement Through Adversarial Testing

Skills tested against realistic failure modes:
Write skill → Test on subagent → Find ways subagent skips it
→ Strengthen language → Retest → Iterate until bulletproof

Uses persuasion principles not as hack but as reliability mechanism:

Authority framing makes instructions stick
Commitment patterns force acknowledgment
Scarcity/pressure scenarios ensure compliance under stress

Result: Skills that survive adversarial testing actually work in practice.
4. Mandatory Compliance Pattern

Bootstrap establishes operating rules:
1. You have skills
2. Skills are discoverable (search tool)
3. If skill exists for task → YOU MUST USE IT

Not "helpful docs" - it's required procedure. Like aviation checklists.
Reinforced by:

EXTREMELY_IMPORTANT framing
Mandatory announcement ("I'm using X skill...")
TodoWrite tracking for checklists
Tested scenarios where agent tries to skip → fails test → skill strengthened

5. Search-Then-Read Pattern

Two-phase discovery:
Phase 1: Search
find-skills [pattern]  # Returns list with when_to_use
Agent matches pattern to task.
Phase 2: Read & Execute
Read skill → Announce usage → Follow checklist
Why separation matters:

Search is cheap (grep/metadata)
Read is expensive (full file in context)
Only read what's needed

6. Self-Improvement Loop

Meta-skill that writes skills:
Agent learns pattern → Extracts to SKILL.md → Tests on subagents
→ If passes: Add to library → Future agents use it

Genius part: System gets smarter over time. Lessons codified, not lost.
7. Subagent Delegation for Context Management

Don't pollute main context with exploration:
Need to search? → Dispatch subagent with query
→ Subagent returns synthesis only
→ Main agent uses result

Principle: Keep main context for active work. Delegate research/search.
Why This Works

Compared to RAG:


RAG: Retrieves chunks, agent figures out what to do
Skills: Retrieves instructions, agent executes

Compared to system prompts:


System prompt: Fixed, everything upfront, context bloat
Skills: Dynamic, loaded on-demand, scales indefinitely

Compared to docs:


Docs: Reference material, agent interprets
Skills: Executable procedures, agent follows

The Meta-Pattern

Skills are code for LLMs.
Not data. Not documentation. Executable procedures that:

Load on-demand (JIT)
Have clear triggers (when_to_use)
Provide unambiguous steps (checklists)
Are tested adversarially (TDD for docs)
Use persuasion principles for reliability
Self-improve (meta-skill writes skills)

The injection system:

Minimal bootstrap (establish rules)
Search tool (discovery)
SKILL.md format (standard interface)
Mandatory compliance (enforcement)
Adversarial testing (quality gate)

Result: System that scales because context cost is O(1) per task, not O(n) for all knowledge.
No results found