# Skill Quality Gate

> Audit the quality of a local skill after creation or revision. Use when deciding whether a skill is ready to lock, needs light or heavy revision, should be merged, or is not worth further investment. Evaluates triggers, scope, overlap, uncertainty handling, handoff quality, and actionability, then returns concrete upgrade steps or a do-not-invest verdict.

- Skill: `alubiama/skill-quality-gate` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add alubiama/skill-quality-gate`
- Raw SKILL.md: https://api.skillmd.com/api/skills/alubiama/skill-quality-gate/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Security
- Author: Alubiama (https://skillmd.com/u/alubiama)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/alubiama/skill-quality-gate

---


# Skill Quality Gate

## Goal

Judge whether a skill is ready to use, needs revision, should be merged, or is not worth more time.

The job of this skill is not to admire the writing. The job is to evaluate operational quality: when the skill triggers, how it behaves, how safely it handles uncertainty, how well it hands off, and whether it adds enough leverage to justify its existence.

This is a specialized profile for skill-only audits. Prefer `quality-gate` for general idea, task, plan, and solution judgments, and use this skill only when a narrow skill-specific review is more useful than the universal gate.

## Default Posture

- gate before praise
- behavior over prose
- leverage over elegance
- concrete revision steps over vague critique
- stop investing when return is too low

## When To Use

Run this skill when:

- a new skill was just created
- an existing skill was substantially revised
- two skills may overlap
- a skill feels conceptually nice but operationally weak
- the team needs a ship / revise / merge / stop decision

Do not use this skill when:

- the object under review is not mainly a skill
- a general proceed / revise / stop judgment is enough
- the broader context matters more than skill-local behavior

This is a mandatory quality gate before:

- locking a new permanent skill
- broadening a skill's trigger scope
- keeping a low-leverage or overlapping skill alive

## Scope Boundaries

In scope:

- audit trigger quality, scope discipline, and output design
- assess overlap and leverage
- check uncertainty handling and escalation paths
- return concrete revisions in priority order
- decide whether more work is justified

Out of scope by default:

- rewriting the entire skill automatically
- validating real-world performance through external experiments
- evaluating business value beyond the skill's operational leverage
- praising style when behavior is weak

## Evaluation Layers

Use three layers in order:

1. `gate_checks`
   - critical failures with no scoring
2. `rubric_scores`
   - focused 0-5 scoring on core dimensions
3. `verdict`
   - final decision and investment recommendation

If a gate failure is critical, do not over-weight the score summary.

## Gate Checks

Check for these critical failures:

- unclear or overly broad trigger
- missing scope boundaries
- missing output contract
- missing guardrails or escalation path
- no actionable next step
- strong overlap with an existing nearby skill
- false certainty with no uncertainty handling
- process complexity far above expected leverage

## Core Rubric

Score 0-5 on:

- `trigger_clarity`
- `scope_discipline`
- `decision_usefulness`
- `uncertainty_honesty`
- `handoff_quality`
- `non_duplication`
- `actionability`
- `context_efficiency`

Use the score to guide revision, not to fake precision.

## Skill-Type Profiles

Add one profile lens based on the skill's role:

- `gate_skill`
  - check false positive risk, false negative risk, and stop-condition quality
- `router_skill`
  - check route minimality, route clarity, and fallback quality
- `framing_skill`
  - check reframing depth and inference discipline
- `ideation_skill`
  - check distinctness and anti-gimmick strength
- `resolution_skill`
  - check leverage identification and testability
- `process_skill`
  - check process economy and convergence quality

If type is unclear, say so and keep the profile light.

## Verdict Types

Choose one:

- `lock`
  - ready to keep as-is
- `revise-light`
  - good core, small targeted improvements needed
- `revise-heavy`
  - useful idea, weak execution
- `merge`
  - overlap is too high; fold into a neighbor
- `do-not-invest`
  - not enough leverage to justify more work now

## Do-Not-Invest Rule

Return `do-not-invest` when one or more are true:

- overlap is high and differentiation is weak
- revisions would be large but expected leverage is small
- the skill solves a problem already covered by a better neighbor
- the skill produces ceremony without improved decisions
- the main issue is not quality but lack of need

In this case, say what to do instead:

- merge into another skill
- tighten an existing skill
- delete or archive
- defer until stronger evidence appears

## Upgrade Path Rule

When verdict is not `lock`, return:

- the top 1-3 revisions only
- in priority order
- each tied to a rubric weakness or gate failure
- each written as an actionable change, not a vague suggestion

Good example:

- add escalation conditions for weak evidence
- narrow trigger to avoid overlap with `creative-method-selector`
- add `recommended_followup` so the handoff is explicit

Bad example:

- improve clarity
- make it stronger
- reduce ambiguity somehow

## Investment Recommendation

Always state how much additional effort is justified:

- `none`
  - stop now
- `small`
  - one focused revision pass
- `medium`
  - a few targeted revisions with retest
- `high`
  - only if leverage is clearly worth it

Use `none` or `small` by default when overlap is high or leverage is uncertain.

## Output Contract

Always return:

1. `skill_type`
2. `gate_findings`
3. `rubric_scores`
4. `profile_findings`
5. `overlap_assessment`
6. `leverage_assessment`
7. `verdict`
8. `investment_recommendation`
9. `upgrade_path`
10. `do_not_invest_reason` (`none` if not applicable)
11. `retest_plan`

## Guardrails

- Do not let a decent average score hide a critical gate failure.
- Do not recommend more revisions than the skill's leverage justifies.
- Do not confuse novelty with value.
- Do not ignore overlap because the wording is different.
- Prefer merge or stop over endless polishing of weak skills.
- Separate confirmed weaknesses from inferred risks.

## Anti-Patterns

Watch for these failure modes:

- score theater
- long critique with no ranked actions
- polishing a skill that should be merged
- judging style instead of behavior
- keeping low-value skills alive because they sound smart
- refusing to say "not worth it"

## Example

Skill under review:

`creative-method-selector`

Expected shape of response:

1. `skill_type`: `router_skill`
2. `gate_findings`: no critical failures; fallback and hold behavior present
3. `rubric_scores`: strong trigger clarity and handoff, moderate overlap risk with full-process skills
4. `profile_findings`: route minimality is good; staged routing needs careful boundary with `creative-problem-solving`
5. `overlap_assessment`: moderate overlap with process-level orchestration, acceptable if selector remains route-only
6. `leverage_assessment`: high; improves the whole creative stack
7. `verdict`: `revise-light`
8. `investment_recommendation`: `small`
9. `upgrade_path`: tighten selector vs process-skill boundary; add explicit examples of when to choose `hold`
10. `do_not_invest_reason`: `none`
11. `retest_plan`: rerun after boundary tightening against `creative-problem-solving` and one real routing case