Skill · AI & Development

Verification-Before-Done

Establish a rigorous definition of done with custom verification protocols for software changes. Stop assuming, start observing. Install in 30 seconds.

Category: AI & Development
Deliverable: 1 .skill bundle
Outputs: —
Last updated: 13 Jun 2026

$8.99 One-time · lifetime updates

Get it on Agensi

Works in Claude Pro, Team, and Enterprise
Lifetime access to updates
Refundable for 30 days via the marketplace

Or get a free skill every month. Subscribers get one curated skill, free, every 1st. Pick yours →

StrategistKit Affiliate. Purchase happens on the marketplace, which handles payment, delivery and refunds.

Overview

What Verification-Before-Done does.

Verification-Before-Done takes the details of a specific software change — what you modified, your runtime environment, and any testing you have already done — and constructs a precise, ordered verification protocol for that change. It identifies the exact commands to execute, the output values or state transitions to observe, the edge cases that the change could silently break, and the regression signals to watch for. The protocol is built for your change, not for a generic ticket category.

A typical input: a backend developer has patched a rate-limiting middleware to fix an off-by-one error in the request window calculation. They paste the diff, describe the environment (Node 20, Redis-backed counters, staging cluster), and note they have only manually hit the endpoint a few times. The skill receives that context and builds the full verification checklist from it.

The output is a structured checklist with labeled sections: commands to run (e.g., specific curl sequences with headers and expected HTTP status codes per request number), state assertions to confirm in Redis after each burst, a list of adjacent code paths that touch the same counter logic with notes on how to exercise them, and a short set of pass/fail criteria that distinguish 'the fix works' from 'it appears to work in this one case.' Each item is actionable without interpretation.

Who it's for

Software engineers and technical leads who close tickets under time pressure and want a concrete, observable definition of done before they merge — particularly useful when the change touches shared infrastructure, async logic, or any path where a silent regression is plausible.

How it works

Three steps. About two minutes.

Install

Add the .skill file to your Claude app. ~10 seconds.

Run it on your work

Invoke the skill and paste in your material.

Apply the output

Review, keep what works, and use it.

In depth

Why a Claude skill beats a prompt template.

A copy-paste prompt runs one static pass and stops. A skill is a bundled program — instructions, examples, and a workflow Claude runs as a unit: it asks for the right input, applies the same pattern every time, and returns the structured outputs above.

FAQ

Common questions.

What information do I need to provide for the skill to generate a useful protocol?

At minimum: a description or diff of what changed, the language and environment the code runs in, and what you have already tested. The more specific you are about the environment and the failure mode that prompted the change, the more targeted the checklist will be.

Does the output include the actual commands I need to run, or just high-level guidance?

It produces specific commands where the context allows — including flags, sample payloads, and the exact output values to look for. For areas where the precise values depend on your local data, it explains what to look for and why, rather than leaving a vague instruction.

Can I use this for any language or stack, or is it limited to certain environments?

The skill adapts to whatever stack you describe. The verification logic it generates is grounded in your stated environment, so a Go service with a PostgreSQL backend and a Python CLI script get different protocols.

How is this different from just writing a test?

Tests encode expected behavior in code and live in your repo. This skill produces a verification protocol for the moment before you close the ticket — covering manual observations, transient state checks, and regression surface that automated tests may not yet cover. The two are complementary.

Is the output a fixed template or does it vary meaningfully per change?

It varies per change. A one-line config fix and a refactor of a shared authentication module will produce substantially different protocols in scope, depth, and the specific signals called out.