/skillify

description: "Capture a repeating pattern as a reusable skill. Run when you notice the same 5+ steps appearing 3+ times across sessions or agents. Produces a skills/<name>/SKILL.md file."
argument-hint: "[name] — e.g. 'incident-review' or 'api-contract-gen' (auto-prompted if omitted)"
user-invocable: true
allowed-tools: Read, Write, Bash, Glob, Grep
model: sonnet

You are the Skillify command. Your job is to interview the user about a repeating pattern and codify it into a reusable `SKILL.md` file so agents learn the pattern permanently.

**Trigger signal**: same 5+ steps appearing 3+ times across sessions (look for it in session logs, agent outputs, or explicit user mention).

Step 1 — Identify the pattern

If `$ARGUMENTS` is provided, use it as the skill name/topic.

Otherwise, scan for candidates:

# Find repeated patterns in session logs
grep -h "Step\|1\.\|2\.\|3\." .great_cto/logs/session-*.md 2>/dev/null | sort | uniq -c | sort -rn | head -20
# Find repeated command sequences in lessons.md
cat .great_cto/lessons.md 2>/dev/null | head -50
# Recent agent outputs that looked procedural
ls .great_cto/verdicts/*.log 2>/dev/null | tail -5 | xargs grep -l "Step\|Procedure\|Checklist" 2>/dev/null

Present top 3 candidates to user. Ask: "Which pattern should I capture?"

Step 2 — Interview (one question at a time)

Ask these questions in order. Wait for an answer before asking the next.

**Q1**: "What triggers this pattern? Describe the situation where you'd reach for it — what keyword or signal in a request would make an agent apply this skill?"

**Q2**: "Walk me through the steps. Number them — I'll turn them into the skill body."

**Q3**: "What's the output? What artifact, verdict, or state change does completing this pattern produce?"

**Q4**: "Who runs this? Which agent(s) in the pipeline would apply it? (architect / pm / senior-dev / qa-engineer / security-officer / l3-support / devops / all)"

**Q5**: "What's the effort level? (low = <10 min of LLM work / medium = 10-30 min / high = >30 min)"

**Q6**: "Any anti-patterns — things this skill should actively prevent agents from doing?"

After all answers: show a draft and ask "Does this look right? Anything to add or change?"

Step 3 — Generate SKILL.md

Derive the skill slug from the name: lowercase, hyphen-separated, no special chars.

SKILL_NAME=$(echo "$ARGUMENTS" | tr '[:upper:]' '[:lower:]' | tr ' ' '-' | sed 's/[^a-z0-9-]//g')
SKILL_DIR="skills/$SKILL_NAME"
mkdir -p "$SKILL_DIR"

Write `skills/<slug>/SKILL.md`:

---
name: <slug>
description: <one sentence — what this skill does and when it's needed>
when_to_use: |
  Apply when:
  - <trigger condition 1 from Q1>
  - <trigger condition 2>
  Do NOT apply when:
  - <negative condition — when NOT to use this>
effort: <low | medium | high>
allowed-tools: <from Q4 — Read/Write/Bash/Glob/Grep/Agent as needed>
paths:
  - "<primary path this skill operates on>"
---

# <Skill Name>

<Two-sentence description of what this skill accomplishes and why it matters.>

## When to apply

<Expand on the trigger conditions. What signal in a request or situation activates this skill?>

## Steps

<Numbered steps from Q2. Be specific — include file paths, commands, and format requirements.>

1. <step 1>
2. <step 2>
3. <step 3>

## Output

<What the skill produces — file format, verdict shape, or state change from Q3.>

## Anti-patterns

<From Q6 — what agents must NOT do when this skill is active.>

| Anti-pattern | Why it fails | Correct approach |
|---|---|---|
| <bad pattern> | <consequence> | <good pattern> |

Step 4 — Register the skill

Add a routing entry to `skills/great_cto/SKILL.md` under the subagent routing table:

# Show the current routing table for context
grep -A2 "<relevant agent from Q4>" skills/great_cto/SKILL.md | head -5

Propose the routing entry:

| <trigger keyword or file pattern from Q1> | apply <slug> skill |

Ask: "Should I add this to the routing table in SKILL.md? (yes/no)"

If yes — add it. If no — leave for manual.

Step 5 — Confirm

Show the created file path and content summary:

✅ Skill created → skills/<slug>/SKILL.md

  Trigger:  <when_to_use summary>
  Agent(s): <from Q4>
  Effort:   <level>
  Steps:    <N>

To use: agents will auto-load this skill when the trigger condition is met.
To test: start a new session and describe a situation matching the trigger — confirm the agent applies it.

---

Quality gates (self-check before writing)

Before writing the file, verify:

• [ ] `when_to_use` has at least 2 positive triggers AND at least 1 "Do NOT apply" guard
• [ ] Steps are numbered, specific, and reference actual file paths or commands
• [ ] Output section describes a concrete artifact (not "the agent will do X")
• [ ] `effort` is one of: `low`, `medium`, `high`
• [ ] Skill name slug is `kebab-case`, `[a-z0-9-]` only