verification-planning

Plans evidence paths for verifying non-trivial code changes before implementation.

Updated Sep 13, 2023
One-click install
npx skills add https://github.com/dlwlrmax/.dotfiles --skill verification-planning-dlwlrmax
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: verification-planning
Source: https://github.com/dlwlrmax/.dotfiles/tree/main/opencode/.config/opencode/skills/verification-planning
Command: npx skills add https://github.com/dlwlrmax/.dotfiles --skill verification-planning-dlwlrmax

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Non-trivial code changes often ship without a credible way to prove they work, leaving teams guessing whether a feature, bug fix, or refactor actually behaves as claimed. This Skill structures the upfront thinking needed to decide how a specific change can be verified before any code is written. ## Core Features & Use Cases - Evidence Path Design: Frames the claim being made, then derives project-specific ways to establish, limit, or refute it using the system's inputs, outputs, state transitions, and boundaries. - Verification Budgeting: Assigns one owner per distinct claim and selects the minimum non-duplicative evidence that covers all claims and important boundaries. - Verification Affordances: Defines the smallest capability (test hooks, resettable state, diagnostic surfaces) that makes the relevant behavior controllable, observable, and repeatable when the existing system is too indirect. - Use Case: Before refactoring a payment retry mechanism, use this Skill to map out which claims must hold (idempotency, ordering, failure recovery), what evidence establishes each, and whether a temporary test affordance is needed to observe internal state. ## Quick Start Ask the agent to plan a verification approach for the feature or bug fix you are about to implement, including the claims to prove and the evidence needed for each.

Frequently Asked Questions about verification-planning

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I plan verification before implementing a code change?▼

Start by framing the claim: state the behavior that must become true and the conditions that could make a confident conclusion wrong. Then derive evidence paths from the system's controllable inputs, observable effects, and state transitions, choosing the path that produces a trustworthy conclusion at proportionate cost.

What is an evidence path in software verification?▼

An evidence path is a project-specific route from the claim being made to evidence that can establish, limit, or refute it. It is derived from the system itself—its inputs, outputs, invariants, boundaries, and ability to repeat or reverse a scenario—rather than from a generic testing technique.

When should I use verification planning versus just running tests?▼

Use verification planning for non-trivial work: features, bug fixes, refactors, cross-system changes, or behavior changes where confidence matters. Small mechanical changes can follow ordinary project checks directly without a formal evidence path.

What is a verification affordance and when do I need one?▼

A verification affordance is the smallest capability that makes relevant state controllable, observable, repeatable, and diagnosable when the existing system leaves the truth too indirect. Build one only when the current evidence path cannot establish the claim directly, and decide upfront whether it is temporary or durable.

How do I avoid over-testing or duplicating verification effort?▼

Set a verification budget: state the distinct claims, assign one owner per claim, and choose the minimum non-duplicative evidence covering all claims and boundaries. Reuse evidence only while its relevant code, inputs, environment, and state remain valid.