Skip to content
Skills Library
AI & agents · Building & coding

verification-skill-create

/verification-skill-create

Use when a project has no verifier for a focus (what is judged, through what) and an agent should from now on judge, alone, the product quality of what is delivered (done as specified, usable, finished): on request, or from the mandate questions of orchestrate-plan when the person says yes. Produces the project's `verify-<app>-<focus>` skill, proven by one quality pass. Not for a focus that has one (its verify skill adapts itself), running a pass (the project's verify skill), tests, code quality or review.

Author
Ovich ↗
Repository
charrette ↗
Licence
MIT
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
9
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when a project has no verifier for a focus (what is judged, through what) and an agent should from now on judge, alone, the product quality of what is delivered (done as specified, usable, finished): on request, or from the mandate questions of orchestrate-plan when the person says yes. Produces the project's `verify-<app>-<focus>` skill, proven by one quality pass. Not for a focus that has one (its verify skill adapts itself), running a pass (the project's verify skill), tests, code quality or review.

Original author description

Use when a project has no verifier for a focus (what is judged, through what) and an agent should from now on judge, alone, the product quality of what is delivered (done as specified, usable, finished): on request, or from the mandate questions of orchestrate-plan when the person says yes. Produces the project's `verify-<app>-<focus>` skill, proven by one quality pass. Not for a focus that has one (its verify skill adapts itself), running a pass (the project's verify skill), tests, code quality or review.

How it works

  1. Before writing
  2. The skill
  3. Prove it
  4. Red flags
Original SKILL.md headings · 36 lines, 908 words
SKILL.md preview
---
name: verification-skill-create
description: "Use when a project has no verifier for a focus (what is judged, through what) and an agent should from now on judge, alone, the product quality of what is delivered (done as specified, usable, finished): on request, or from the mandate questions of orchestrate-plan when the person says yes. Produces the project's `verify-<app>-<focus>` skill, proven by one quality pass. Not for a focus that has one (its verify skill adapts itself), running a pass (the project's verify skill), tests, code quality or review."
---

# Create a verification skill

**One thing is produced, and a later agent works from it alone**: the project's verifier for one focus, `verify-<app>-<focus>` (plain `verify-<app>` while the project has one only). A project keeps as many as it has focuses, whatever they are; for example: the app judged end to end in its browser, the API judged by its requests, whatever a project's workbench shows judged on it. The skill is short, as a proven project skill is: an agent arriving cold reads it in a minute and works.

**The skill opens on its role prompt and leaves the judging to the agent**: one paragraph that makes the agent the product's quality owner, seen through expert roles (a web product's UI/UX expert and art director among them). Written as `references/role-prompt.md` says, read before the first line, with the surface's roles from its harness reference.

**The verify skill validates the product, never the code.** It reaches and judges everything through the surface the consumer uses; reading the source is this skill's job, done once here, never the verify skill's.

## Before writing

**Four decisions are the person's, settled through the `interview` skill, one at a time, each proposed with its reason**: the focus, the inputs and their defaults, the experts, the feature to prove it on. The rest is established from the repository.

- **Understand the project, then settle the focus with the person**: what this verifier judges and through what. The project can be anything (an app, a service, a library, a pipeline); the candidates come from what it is: every surface it offers its consumers and every way the project already runs or judges a part of it, each proposed with what it would judge and why, one recommended. The examples above are examples, never the list. **Stop if a verifier with that focus exists**: it keeps itself true when run. Say so; never overwrite one. A first verifier named plain `verify-<app>` is renamed to its focus when a second is created, on the person's yes.
- **A project skill that already runs the app stays its own**, shared by every verifier: it is proven, and the next verifier needs it too. The verify skill names it in *Run the app* and restates none of it. None: the steps to run the app go in the verify skill, and a second verifier moves them into a skill of their own.
- **Establish from the repository, never by asking**: the consumer and what they come for, the interface they use, how the app starts and signals ready, the tool the agent acts through, where the specification lives (plans and their stories, decisions, reference prototypes, the `design-prototype` skill's design language), and **the inputs a pass of this focus depends on** (the widths and themes among them, where the focus has any), each with its default (`references/verify-skill-template.md`, *Scope and inputs*): a default follows the project's decisions first (its plans, its prototypes), its code second, and is the cheapest pass that answers the focus (the widths: the prototypes', not the code's breakpoints); the rest the scope sets. **The reference and its fidelity is an input of every focus with a prototype**: the experience, the layout, or a pixel match.
- **The harness reference** of the interface, read for the tool to act through and its observations, its expert roles an example to choose from (`references/role-prompt.md`): `references/web.md`, `api.md`, `service.md`, `cli.md` or `mcp.md`. A tool the agent operates is built as `references/tooling.md` says.

## The skill

**`verify-<app>-<focus>/SKILL.md`** in the project's local skill folder, written to the shape in `references/verify-skill-template.md`, read before the first line.

## Prove it

**Run one quality pass through the generated skill** on the feature to prove it on: the smallest delivered feature that exercises the focus, chosen only to prove the skill, never what the verifier covers. It is taken from the product as it stands now (the roadmap and the newest plans read first), with references that still describe it, never a feature since reworked, proposed to the person with what was established to run it (the start, the ready signal, how the agent's tool is opened), run on their yes or on the one they name instead, by a fresh agent on the plugin's `verifier` agent (`subagent_type: "swarmstorm:verifier"`), its brief the skill's name, the feature as its scope and the inputs that differ from the defaults: an agent arriving cold is what the skill is written for. The skill is proven when the pass is complete: every part of the scope reached, judged against its inputs, the verdict and its findings table in its report. A `not ready` verdict proves it as well as `ready`; what the pass finds on the app is reported, never fixed inside this skill. A part it could not reach fails on the skill: fix it and run again.

**Handoff**: the skill's path, its focus, the pass's report.

## Red flags

| Thought | Reality |
|---|---|
| "A list of what to check makes the skill thorough" | The agent checks that list and stops. The role prompt and the three counts are the protocol; the judgment is the agent's. |
| "The inputs are obvious" | The verifier guesses them and judges against the wrong reference. Each has a default in the skill or comes in the scope. |
| "The existing run skill could be written better" | It is proven. Wrap it; reword nothing that works. |
Files in this package (9)
  • SKILL.md 6 KB
  • references/api.md 1 KB
  • references/cli.md 1 KB
  • references/mcp.md 1 KB
  • references/role-prompt.md 2 KB
  • references/service.md 1 KB
  • references/tooling.md 1 KB
  • references/verify-skill-template.md 4 KB
  • references/web.md 2 KB

Versions

The database has no other skills named verification-skill-create.

Database snapshot: 13.11.2026 · package version 4f70be603cd5 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100verification
    Full agent verification suite. Runs security, patterns, quality, and language-specific checks. Use when asked to "verify agent", "verify my agent", "audit agent", or "full verification".
  • 90agents-create-verification-skill
    Generate a project-local verify skill that drives the app like a user through a browser with Playwright, a CLI, or HTTP. Use for /agents-create-verification-skill, "make a verify skill for this repo", or when a project has no scripted way to prove UI, CLI, or service behavior.
  • 100meta-verify
    Runs a second-pass quality check on a skill's output before it goes out, re-checking it against the originating skill's Quality Gate and Operating Rules and returning specific fixes, not just pass/fail. Trigger on: "verify this", "check this before I send it", "second-pass this…
  • 100verification-skill
    Create, adopt or maintain a project's own verify-<app> skill, the scripted way for any agent to launch the real app, drive a feature the way a user does, and capture proof. Use for "create a verification skill", "make a control skill for this repo", "set up verification for this…
  • 100harness
    Run harness tests to verify everything-evenhub skill quality. Dispatches an implementer subagent guided by the skill, then a verifier subagent with a structured checklist. Use to validate any skill works correctly.
  • 86validate-delivery
    Use when the person and the agent go over what was just delivered together, live: on execute-plan's recommendation at a plan's close, or whenever the person asks to walk or rework a delivery with the agent. Runs the project's verify skill with the person guiding it, judging and…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.