pattern-name

Analyze conversation to identify and capture reusable patterns as skills, commands, agents, or hooks. Use when spotting repeatable workflows, orchestration sequences, or decision heuristics worth codifying. Triggers on pattern(s), capture, codify, reusable, workflow, or `--patternify`.

⭐4stars🔀0forks📁View on GitHub🕐Updated Dec 31, 2025⬇️1downloads

When & Why to Use This Skill

Patternify is a sophisticated Claude skill designed to analyze conversational data and transform repeated behaviors into structured, reusable AI components. By identifying workflows, orchestration sequences, and decision heuristics, it enables users to codify manual processes into Skills, Commands, Agents, or Hooks, significantly enhancing the efficiency and consistency of AI-driven automation.

Use Cases

  • Workflow Codification: Identify successful multi-step processes (e.g., Debug → Test → Fix) and convert them into reusable Skills to standardize future task execution.
  • Heuristic Extraction: Capture complex decision-making rules and 'if-then' logic from expert conversations to create consistent AI decision trees.
  • Tool Orchestration: Recognize patterns where multiple tools (like Git, Jira, and PR bots) are used in sequence and automate the entire coordination flow.
  • SOP Development: Automatically generate Standard Operating Procedures (SOPs) by extracting repeatable patterns from manual user-agent interactions.
  • Agent Architecture Design: Use identified interaction patterns to determine whether a task should be handled by a simple Command, a reactive Hook, or an autonomous Agent.
namepatternify
version1.1.0
descriptionThis skill should be used when capturing reusable workflows from conversations, codifying decision heuristics, or when "patternify", "capture", or "codify workflow" are mentioned.

Patternify

Conversation analysis → reusable pattern → correct component.

  • Spotting repeated behavior worth codifying
  • User explicitly wants to capture a workflow
  • Recognizing orchestration sequences in conversation
  • Identifying decision heuristics being applied

NOT for: one-off tasks, simple questions, well-documented existing patterns

Type Purpose Example
Workflow Multi-step sequences Debug → Test → Fix → Verify
Orchestration Tool coordination Git + Linear + PR automation
Heuristic Decision rules "When X, do Y because Z"

Workflows: Step-by-step processes with defined phases and transitions. Orchestration: Tool combinations that work together for a goal. Heuristics: Conditional logic and decision trees for common situations.

Match pattern type to implementation:

Is it a multi-step process with phases?
├─ Yes → Does it need tool restrictions?
│        ├─ Yes → Skill (with allowed_tools)
│        └─ No → Skill
└─ No → Is it a simple entry point?
         ├─ Yes → Command (thin wrapper → Skill)
         └─ No → Is it autonomous/long-running?
                  ├─ Yes → Agent
                  └─ No → Is it reactive to events?
                           ├─ Yes → Hook
                           └─ No → Probably doesn't need codifying

Composites:

  • Skill + Command: Skill holds logic, command provides entry point
  • Skill + Hook: Skill holds logic, hook triggers automatically
  • Agent + Skill: Agent orchestrates, skill provides methodology

Pattern spec format (YAML):

name: pattern-name
type: workflow | orchestration | heuristic
trigger: when to apply
phases:  # workflow
  - name: phase-name
    actions: [...]
    exit_criteria: condition
tools:   # orchestration
  - tool: name
    role: purpose
    sequence: order
rules:   # heuristic
  - condition: when
    action: what
    rationale: why
quality:
  specific: true | false
  repeatable: true | false
  valuable: true | false
  documented: true | false
  scoped: true | false

All five quality checks must pass before codifying.

  1. Identify: Spot repeatable behavior in conversation
    • For deep analysis, load codebase-analysis skill and use pattern-analysis techniques
    • Extract success, frustration, workflow, and request signals
    • Look for 3+ occurrences of similar behavior
  2. Classify: Workflow, Orchestration, or Heuristic?
  3. Map: Which component(s) should implement it?
  4. Specify: Document with pattern spec format
  5. Quality: Validate against SRVDS criteria
  6. Implement: Create the component(s)

TodoWrite phases:

- Identify { pattern description }
- Classify { pattern type }
- Map { component decision }
- Specify { pattern name }
- Implement { component type }

SRVDS criteria — all must pass:

Check Question Red Flag
Specific Clear trigger + scope? "Sometimes useful"
Repeatable Works across contexts? One-off solution
Valuable Worth the overhead? Saves < 5 minutes
Documented Can others understand? Tribal knowledge
Scoped Single responsibility? Kitchen sink

Skip if: < 3 occurrences, context-dependent, simpler inline

  • Premature abstraction: Codifying after first occurrence
  • Over-specification: 50-line spec for 5-line pattern
  • Wrong component: Hook when Skill needed, Agent when Command suffices
  • Missing trigger: Pattern exists but no clear activation
  • Scope creep: Pattern grows to handle edge cases

ALWAYS:

  • Identify pattern type before choosing component
  • Validate all SRVDS criteria
  • Start with minimal implementation
  • Document trigger conditions clearly
  • Test pattern in at least 2 contexts

NEVER:

  • Codify after single occurrence
  • Create Agent when Skill suffices
  • Skip quality validation
  • Implement without clear trigger
  • Add "might need later" features