/skillify

name: skillify
version: 2.0.0
description: |
  The meta skill. Turn any raw feature into a properly-skilled, tested,
  resolvable unit of agent capability. Idempotent: running on an existing
  skill improves it (bug fix, new input, quality pass) instead of starting
  from scratch. Every skill declares an EVAL CONTRACT (its goal +
  skill-specific dimensions + hard-fails) so the cross-modal eval judges
  THIS skill's real purpose, not generic slop. Cross-modal eval runs BEFORE
  tests: 3 frontier models from different providers critique the output
  against the contract, you iterate to quality, THEN write/update tests that
  lock in the proven-good behavior. NO-REGRESSION LAW: any edit to a skill
  must score >= the previous iteration's eval — forward only, never back.
  For skills that back a scheduled job, an edit MUST re-run a representative
  task and eval it before shipping.
eval_contract:
  goal: |
    Turn a raw feature or an edited skill into a properly-skilled, regression-proof
    unit: all 15 checklist items pass, the output clears its own eval contract, and
    the new eval scores >= the prior iteration. Excellent = another operator on any
    agent platform can run skillify and know exactly what passed, what the quality
    bar was, and that nothing silently regressed.
  dimensions:
    - "CHECKLIST_COVERAGE — are all 15 items actually checked, not just claimed?"
    - "CONTRACT_QUALITY — is the eval_contract goal concrete and the dimensions skill-specific (not generic)?"
    - "REGRESSION_RIGOR — is the new output compared to the prior baseline with a real delta?"
    - "IDEMPOTENCY — does an improve-run preserve what worked and fix only the delta?"
    - "GENERALITY — is the skill deployment-neutral (no hardcoded people or channels in the body)?"
    - "ACTIONABILITY — could another operator follow this without asking follow-ups?"
  hard_fails:
    - "Shipping a skill edit that scores worse than the prior iteration (regression)."
    - "Running cross-modal eval on generic dimensions for a high-stakes skill instead of its contract."
    - "Editing a schedule-backed skill without re-running and evaluating a representative task."
    - "Hardcoding one deployment's people or channels into the skill body instead of a neutral principle."
triggers:
  - "skillify this"
  - "skillify"
  - "is this a skill?"
  - "make this proper"
  - "add tests and evals for this"
  - "check skill completeness"
  - "run skillify on a skill"
  - "did this skill regress"
tools:
  - exec
  - read
  - write
  - edit
mutating: true
upstream: skillify@fc834ee

Skillify — The Meta Skill

> **Relationship to `/cross-modal-review`:** That skill is the manual mid-flow > "second opinion" gate (one model reviews work product before commit). This > skill's Phase 3 below uses `gbrain eval cross-modal` instead — three > different-provider frontier models score-and-iterate on a documented > dimension list *before* tests cement behavior. Use `/cross-modal-review` > for ad-hoc second opinions; use Phase 3 here when skillifying a feature.

Contract

A feature is "properly skilled" when all 15 checklist items (0 + 1–14; 3b rides with item 3) pass. `gbrain skillify check` audits the mechanical items (1–11); items 0, 3b, 12, 13, and 14 are procedural gates the agent verifies directly. Item 3 (cross-modal eval) is informational in the audit — it does not gate `gbrain skillify check`, but a missing or stale receipt is surfaced so the user knows where the gate stands.

**Idempotency guarantee:** skillify can run on the same skill any number of times. Each run:

1. Detects existing artifacts (SKILL.md, tests, evals, code, resolver entries) 2. Identifies what's new: bug report, user feedback, new input, or quality gap 3. Improves existing files rather than rewriting from scratch 4. Preserves what works, fixes what's broken 5. Re-runs the checklist and only touches items that fail

**No-regression law:** any edit to a skill must score ≥ the previous iteration's cross-modal eval on the same task and dimensions. Forward only, never back (Phase 3.5).

The Checklist

Other skills and workflows delegate to this checklist — reference items by number (e.g. "run skillify items 4–6") against `skills/skillify/SKILL.md`. The numbering is stable; additive changes only.

□ 0.  Eval contract      — skill declares goal + skill-specific dimensions + hard-fails (Phase 2.5)
□ 1.  SKILL.md           — skill file with frontmatter + contract + phases
□ 2.  Code               — deterministic script if applicable
□ 3.  Cross-modal eval   — 3 frontier models from 3 providers critique output vs the contract; informational in the audit
□ 3b. No-regression gate — new eval scores ≥ the previous iteration (forward only; Phase 3.5)
□ 4.  Unit tests         — cover every branch of deterministic logic
□ 5.  Integration tests  — exercise live endpoints
□ 6.  LLM evals          — quality/correctness cases for LLM-involving steps
□ 7.  Resolver trigger   — entry in skills/RESOLVER.md with real user trigger phrases
□ 8.  Resolver eval      — test that triggers route to this skill
□ 9.  Check-resolvable   — DRY + MECE audit, no orphans
□ 10. E2E test           — smoke test: trigger → side effect
□ 11. Brain filing       — if it writes pages, entry in brain/RESOLVER.md
□ 12. Scheduled-run observability — if the skill backs a cron/recurring job, runs route through minions so they are logged and inspectable (Phase 6)
□ 13. Scheduled-task re-run — if the skill backs a cron, an edit re-runs a representative task + evals it (Phase 3.5)
□ 14. Plugin membership   — record the skill in openclaw.plugin.json OR skills/plugin-exclusions.json (the membership test requires exactly one)

Phase 0: Determine Mode (New vs Improve)

Before anything, determine the mode.

Mode A: New Skill (no SKILL.md exists)

Check:

• Will this be invoked 2+ times? (One-off work ≠ skill)
• Is there >20 lines of logic? (Trivial helpers don't need full infrastructure)

-