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`.
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.
| name | patternify |
|---|---|
| version | 1.1.0 |
| description | This 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.
- 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
- Classify: Workflow, Orchestration, or Heuristic?
- Map: Which component(s) should implement it?
- Specify: Document with pattern spec format
- Quality: Validate against SRVDS criteria
- 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
- codebase-analysis — core investigation methodology
- pattern-analysis — signal extraction techniques
- pattern-types.md — extended examples by type
- component-mapping.md — decision tree details
- examples/ — captured pattern examples