Skill · AI & Development

Verification-Before-Done

Verification-Before-Done is a Claude skill for AI & Development. Establish a rigorous definition of done with custom verification protocols for software changes. It costs $8.99 on Agensi. It runs on any paid Claude plan. Part of the StrategistKit catalog of 190+ focused Claude skills.

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

$8.99 One-time · lifetime updates

Become a member to fetch

10 credits — included with a membership (30 credits/mo).

Prefer a one-time purchase, without joining?

Buy once on Agensi

StrategistKit Affiliate. One-time purchase on Agensi. Payment, delivery and refunds are handled by the marketplace — see their policy for refund terms.

Works in Claude Pro, Team, and Enterprise
Lifetime access to updates
One-time purchase on Agensi. Payment, delivery and refunds are handled by the marketplace — see their policy for refund terms.

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

Included in Complete Collection 195 skills for $149. View bundle →

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. About 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.