create-verification-skill
/create-verification-skill
Generate a project-local verification skill that drives your app the way a user does — any language, framework, or platform. Use for /create-verification-skill, \"make a control skill for this repo\", or when a project has no scripted way to prove UI/CLI/service behavior.
- Author
- painhardcore ↗
- Repository
- pstack ↗
- Licence
- MIT
- Last repository change
- 13.11.2026
Assessment and security
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 13.11.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Generate a project-local verification skill that drives your app the way a user does — any language, framework, or platform. Use for /create-verification-skill, \"make a control skill for this repo\", or when a project has no scripted way to prove UI/CLI/service behavior.
Triggers from the description
Original author description
Generate a project-local verification skill that drives your app the way a user does — any language, framework, or platform. Use for /create-verification-skill, \"make a control skill for this repo\", or when a project has no scripted way to prove UI/CLI/service behavior.
How it works
- 1. Interview the repo, not the user
- 2. Generate the skill
- 3. Seed the feature map
- 4. Prove the generated skill before handing it over
- 5. Offer the maintenance loop
SKILL.md preview
--- name: create-verification-skill description: "Generate a project-local verification skill that drives your app the way a user does — any language, framework, or platform. Use for /create-verification-skill, \"make a control skill for this repo\", or when a project has no scripted way to prove UI/CLI/service behavior." --- # Create a verification skill Every serious project needs a scripted way to drive the real app and prove behavior: launch it, exercise a feature the way a user would, and capture evidence. This skill generates a project-local `verify-<app>` skill tailored to the repo. Read [references/host-paths.md](references/host-paths.md), choose the active host's one project skill root, and call it `<skill-root>` below. Write for the next agent, which will read the result cold and mid-task. ## 1. Interview the repo, not the user Answer these from the codebase and only ask the user what you cannot observe: - **Surface:** what does a user actually touch? A web UI, a CLI/TUI, a desktop app, an API, a mobile app, a library? A repo can have several; pick the primary one and note the rest. - **Run:** how does the app start locally? Prefer the repo's own documented dev command (package scripts, Makefile, README quickstart). Note ports, env vars, seed data, auth. - **Drive:** how can an agent interact with it programmatically? Existing harnesses first — Playwright/Cypress specs, expect scripts, PTY helpers, curl-able endpoints, a debug port. Only then pick a generic recipe: browser/CDP for web and Electron, a tmux/PTY harness for CLI/TUI, plain HTTP for services. - **Observe:** what evidence can be captured? Screenshots, terminal transcripts, response bodies, logs, exit codes, DB state. - **Isolate:** can two instances run side by side (ports, data dirs, profiles)? If not, say so in the generated skill: refusing to double-drive a shared instance beats corrupting the user's session. If the checkout doesn't build or start as-is, fix that first (or report it precisely) before generating; a skill written against a broken base teaches wrong steps. When an irrelevant missing asset blocks startup (a static dir the API never serves, a sample config), the generated skill may create it, clearly marked as verification scaffolding, and remove it in cleanup. ## 2. Generate the skill Write `<skill-root>/verify-<app>/SKILL.md` with YAML frontmatter (`name: verify-<app>` and a `description` that names the app, the surface, and when to reach for it — without frontmatter the skill never registers) and these sections, each grounded in what the interview actually found (no placeholders left): - **Launch:** the exact command that starts the app for verification, and how to tell it's ready (a log line, a prompt). Launch must reach a usable state from an empty data dir, including any migrations and seed data. Ready means usable, not just that a process answers. A database health check can pass while its init scripts are still running. Include teardown. For a short-lived CLI or TUI there is no server to keep alive: launch means build the binary (or install deps) once, then start each drive in its own isolated PTY or tmux session. - **Doctor:** one read-only check that answers "is this instance worth driving?" — process up, right version/build, port owned by us, auth valid. An agent runs this first whenever anything looks off. - **Drive:** the harness recipe with real selectors/commands from this repo, not examples. Prefer stable handles (ARIA labels, data attributes, prompt strings, route paths) over coordinates and tab order. - **Evidence:** what to capture for a proof and where it goes. State the proof standards: exercise the real user path, not internal setters or test-only endpoints; capture the action and the resulting state, not just the final screen; verify side effects (files written, rows inserted, messages sent) alongside what's visible; mocks only where a production boundary already isolates the external system. When the safe path is a dry-run or test mode, verify what it actually skips by observing (files, network, git refs) rather than trusting its name: some dry-runs still touch the network or open a browser. - **Cleanup:** how to tear down instances the run created. Never kill by process name; kill what you started. Cleanup removes instances and scratch state, never the evidence: proof artifacts survive the teardown, in a location the skill names. - **Helpers:** any script the skill ships is executable and its invocation is shown in the skill body. A helper the reader has to reverse-engineer is not a helper. ## 3. Seed the feature map Create `<skill-root>/verify-<app>/features/README.md` plus one file per user-facing feature you can identify (aim for the top 3-5 to start, from routes, commands, menus, or docs), with a README index and one file per feature. Each file answers, from the user's point of view: what the feature is, how to reach it, how to drive it with the harness, and what observable end state proves it works. The four H2s are `Sub-features`, `How to get to it (user POV)`, `Driving it with <harness>`, and `Gotchas`. If the seed data lacks a precondition that a journey needs, the journey reports a failure and the reason goes in that feature's `Gotchas`. Never weaken the journey to make it pass. The map is the repo's maintained verification source; a proof that drives one convenient entry point is incomplete when the map lists others. ## 4. Prove the generated skill before handing it over Run its own instructions end to end once: launch, doctor, drive ONE mapped feature (one is enough; the map exists so later runs can cover the rest), capture evidence, clean up. After cleanup, confirm the evidence still exists at the named location — a cleanup that eats the proof fails this step. Fix what fails, and run the generated cleanup after every failed iteration too, so broken attempts don't strand processes and ports. A generated skill that was never executed is a draft, not a deliverable. If you proved it in a stand-in for the real target (a container in place of a fresh VM, a local stack in place of a remote one), list every setup step the stand-in did that the target will not. Those steps stay unverified until a run on the real target covers them. ## 5. Offer the maintenance loop Point the user at **maintain-verification-skill** for keeping the map honest as the app changes. Suggest a cadence only if they ask.
Files in this package (2)
- SKILL.md 6 KB
- references/host-paths.md 1 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · painhardcore/pstack | 100 | MIT |
| e2e-inc/e2e | 100 | Apache-2.0 |
| tester-army/e2e | 100 | Apache-2.0 |
| TimothyVang/deepmodebot | 100 | MIT |
| Calvin-LLC/skills | 100 | MIT |
| arjitj2/open-pstack | 100 | MIT |
| paperclipai/paperclip | 100 | MIT |
| backnotprop/pstack | 100 | MIT |
| kriscard/Skills | 100 | MIT |
Database snapshot: 13.11.2026 · package version 4d2c73322e76 (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
- 100prove-e2e-create
Generate a repo-local skill, verify-<app>, that launches this repo's app, drives a feature the way a user does, captures evidence, and cleans up, in any language or platform. Seeds a feature map and proves the new skill by running it once. Use when a repo has no scripted way to… - 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. - 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… - 100vital-signs
Katara checks the vital signs so she knows the patient is really well, not just quiet. Use for create-verification-skill, /create-verification-skill, "make a control skill for this repo", "make a driver skill for this repo", or when a project has no scripted way to prove UI,… - 86verify-create
Build a project's own verify skill that launches the real app, drives each user-facing feature in a real browser, and keeps a feature map. Use when a project has a UI or front end and no scripted way to prove it works, or when the user asks for a verification skill. - 100create-verify-skill
Create a project verify-<app> skill that drives the running app the way a user does, with agent-browser for web apps and tuistory for terminal apps. Use when a project has no verify skill yet; not to refresh a drifted one (use maintain-verify-skill), not to draft a generic skill…