Agent Skills: Pattern Identification

Pattern Identification

Observe signals → classify patterns → validate with evidence → document findings.

Steps

1. Collect signals from conversation, code, or data
2. Classify pattern type (workflow, orchestration, heuristic, anti-pattern)
3. Validate against evidence threshold (3+ instances, multiple contexts)
4. Document pattern with constraints and examples
5. If implementation needed, delegate by loading the outfitter:codify skill

<when_to_use>

• Recognizing recurring themes in work or data
• Codifying best practices from experience
• Extracting workflows from repeated success
• Identifying anti-patterns from repeated failures
• Building decision frameworks from observations

NOT for: single occurrences, unvalidated hunches, premature abstraction

</when_to_use>

<signal_identification>

Watch for these signal categories:

| Category | Watch For | Indicates | |----------|-----------|-----------| | Success | Completion, positive feedback, repetition, efficiency | Pattern worth codifying | | Frustration | Backtracking, clarification loops, rework, confusion | Anti-pattern to document | | Workflow | Sequence consistency, decision points, quality gates | Process pattern | | Orchestration | Multi-component coordination, state management, routing | Coordination pattern |

See signal-types.md for detailed taxonomy.

</signal_identification>

<pattern_classification>

Four primary pattern types:

| Type | Characteristics | Use When | |------|-----------------|----------| | Workflow | Sequential stages, clear transitions, quality gates | Process has ordered steps | | Orchestration | Coordinates components, manages state, routes work | Multiple actors involved | | Heuristic | Condition → action mapping, context-sensitive | Repeated decisions | | Anti-Pattern | Common mistake, causes rework, has better alternative | Preventing failures |

See pattern-types.md for templates and examples.

</pattern_classification>

<evidence_thresholds>

Codification Criteria

Don't codify after first occurrence. Require:

• 3+ instances — minimum repetition to establish pattern
• Multiple contexts — works across different scenarios
• Clear boundaries — know when to apply vs not apply
• Measurable benefit — improves outcome compared to ad-hoc approach

Quality Indicators

| Strong Pattern | Weak Pattern | |----------------|--------------| | Consistent structure | Varies each use | | Transferable to others | Requires specific expertise | | Handles edge cases | Breaks on deviation | | Saves time/effort | Overhead exceeds value |

</evidence_thresholds>

<progressive_formalization>

Observation (1-2 instances):

• Note for future reference
• "This worked well, watch for recurrence"

Hypothesis (3+ instances):

• Draft informal guideline
• Test consciously in next case

Codification (validated pattern):

• Create formal documentation
• Include examples and constraints

Refinement (ongoing):

• Update based on usage
• Add edge cases

</progressive_formalization>

Loop: Observe → Classify → Validate → Document

1. Collect signals — note successes, failures, recurring behaviors
2. Classify pattern type — workflow, orchestration, heuristic, anti-pattern
3. Check evidence threshold — 3+ instances? Multiple contexts?
4. Extract quality criteria — what makes it work?
5. Document pattern — name, when, what, why
6. Test deliberately — apply consciously, track variance
7. Refine — adjust based on feedback

ALWAYS:

• Require 3+ instances before codifying
• Validate across multiple contexts
• Document both when to use AND when not to
• Include concrete examples
• Track pattern effectiveness over time

NEVER:

• Codify after single occurrence
• Abstract without evidence
• Ignore context-sensitivity
• Skip validation step
• Assume transferability without testing

• signal-types.md — detailed signal taxonomy
• pattern-types.md — pattern templates and examples

Identification vs Implementation:

• This skill (patterns) identifies and documents patterns
• codify skill implements patterns as Claude Code components (skills, commands, hooks, agents)

Use patterns to answer "what patterns exist?" Use codify to answer "how do I turn this into a reusable component?"