skillify

What this skill does

# Skillify

Extract reusable patterns from the current conversation session and delegate their creation as skills to `plugin-dev:skill-development`. This skill extracts and shapes -- it never creates skills directly.

## When to Use

**Explicit triggers:**
- User says "skillify", "extract a skill", "learn this", "distill this into a skill"
- User says "turn this into a skill", "capture this workflow", "save this pattern"
- User asks "can we reuse this?" or "this should be a skill"

**Proactive triggers (suggest briefly):**
- After completing a multi-step debugging workflow that solved a non-trivial problem
- After a deployment procedure that required specific sequencing or gotchas
- After discovering a decision tree that recurred across sessions
- When a conversation reveals a repeatable process worth codifying
- Briefly suggest: "This looks like a reusable pattern. Want me to skillify it?"

## Core Flow

### Phase 1 -- Extraction Engine

Scan the full session context for extractable patterns. Prioritize in this order:

1. **Workflow patterns** (PRIMARY) -- Multi-step processes, decision trees, sequences that solved problems, debugging workflows, deployment procedures, investigation playbooks.
2. **Code patterns** (SECONDARY) -- Reusable approaches, conventions, architectural patterns that emerged organically during implementation.
3. **Decision patterns** (SECONDARY) -- Recurring choices, rules of thumb, heuristics that guided the session's direction.

For each pattern found, construct a **pattern brief**:

```
Pattern Name: <descriptive name>
Type: workflow | code | decision
Summary: <1-2 sentence description>
Steps/Rules: <the actual pattern, numbered if workflow>
When to use: <trigger conditions>
Why it works: <session context for why this approach was chosen>
```

**If no patterns found:** Exit gracefully. Do not force extraction. Instead, suggest alternatives based on what WAS observed in the session:
- A memory entry (if the insight is session-specific context)
- A CLAUDE.md rule (if it's a standing instruction)
- A feedback entry (if it's a behavioral correction)

State clearly: "No reusable patterns found in this session. Here's what I did find and where it fits better: ..."

**If session is too short:** Say so honestly. "This session doesn't have enough context to extract meaningful patterns. Continue working and invoke skillify again later."

### Checkpoint 1 -- Pattern Approval

Present all discovered patterns as a numbered list of pattern briefs. Then STOP and wait for user input.

```
I found N extractable pattern(s):

1. **<Pattern Name>** (workflow)
   <Summary>

2. **<Pattern Name>** (code)
   <Summary>

Which patterns should I hand off to skill-development?
- Pick by number (e.g., "1 and 3")
- Refine a brief (e.g., "update 2 to include X")
- Reject all (e.g., "none of these")
```

Do NOT proceed until the user explicitly approves, refines, or picks patterns. If the user rejects all, exit gracefully.

After approval, ask: **"Which plugin should this skill live in?"** Wait for the answer before proceeding.

### Phase 2 -- Handoff to skill-development

For each approved pattern, invoke `plugin-dev:skill-development` via the Skill tool with a structured handoff prompt containing:

1. The approved pattern brief -- verbatim, as approved or refined by the user.
2. The target plugin path -- as specified by the user.
3. The directive:

> "The user has already completed the discovery phase. Use the pattern brief below as your input -- skip steps 1-2 of your workflow and proceed directly to creating the skill structure and writing the SKILL.md."

Construct the handoff as a single, self-contained prompt. Do not assume skill-development has access to this conversation's context.

### Phase 3 -- Quality Gate

After `plugin-dev:skill-development` completes, invoke `plugin-dev:skill-reviewer` to validate the newly created skill. Surface the quality report to the user.

### Checkpoint 2 -- Validation

Present the skill-reviewer's quality report. STOP and wait for the user to review.

- If the user accepts: confirm completion.
- If the user requests changes: relay feedback to skill-development for another pass.
- If skill-development or skill-reviewer fails at any point: surface the error clearly. Do NOT attempt to create the skill directly.

## Edge Cases

| Scenario | Response |
|----------|----------|
| No patterns found | Exit gracefully, suggest memory entry / CLAUDE.md rule / feedback instead |
| Session too short | Say so honestly, suggest invoking later |
| Multiple patterns found | Numbered list, user picks which to extract |
| User wants all patterns | Process sequentially, one skill-development handoff per pattern |
| skill-development fails | Surface the error, do not create the skill directly |
| skill-reviewer fails | Surface the error, still present the skill for manual review |
| Pattern is too vague | Ask user to refine the brief before handoff |
| User provides input instead of session scan | Politely redirect: "Let me scan the session first, then we can refine" |

## This Skill Does NOT

- Write SKILL.md files directly -- that is skill-development's job.
- Create directory structures for new skills -- that is skill-development's job.
- Validate skill quality -- that is skill-reviewer's job.
- Accept user-provided descriptions as a substitute for session scanning. Always scan first, then refine with user input.
- Pre-judge which patterns are "worth it." Extract all candidates, let the user decide.
- Skip checkpoints. Both approval gates are mandatory.

## Red Flags -- Recognize and Correct

These thoughts mean the extraction is going off-track:

| Impulse | Correction |
|---------|------------|
| "Let me just write the SKILL.md directly" | Stop. Hand off to skill-development. |
| "This pattern isn't worth extracting" | Present it anyway. User decides value. |
| "I'll skip the pattern brief and go straight to creation" | Stop. Brief first, approval second, handoff third. |
| "The user described what they want, no need to scan" | Scan anyway. Session context adds nuance user descriptions miss. |
| "skill-development failed, I'll create it myself" | Surface the error. Never bypass the pipeline. |
| "One checkpoint is enough" | Both checkpoints are mandatory. No shortcuts. |