verification-ladder

Map code changes to testing rungs and report confidence levels.

2|Updated Mar 5, 2026
One-click install
npx skills add https://github.com/likesjx/philotic-stack --skill verification-ladder
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: verification-ladder
Source: https://github.com/likesjx/philotic-stack/tree/main/skills/verification-ladder
Command: npx skills add https://github.com/likesjx/philotic-stack --skill verification-ladder

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps determine the appropriate level of validation for a code change and clearly communicates the confidence in its correctness, preventing over- or under-testing.

Core Features & Use Cases

  • Validation Planning: Guides the selection of testing strategies based on the nature and impact of a code change.
  • Confidence Classification: Provides a framework for honestly assessing and reporting the confidence level in a change's stability.
  • Use Case: When a developer makes a change to the core networking module, this Skill can be used to decide whether unit tests are sufficient, or if integration tests and a watched live run are necessary, and then report that the confidence level is 'smoke-green'.

Quick Start

Use the verification-ladder skill to determine the appropriate validation steps for a change affecting the user authentication module.

Frequently Asked Questions about verification-ladder

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

FAQPage Schema
How do I determine the appropriate testing depth for a code change?

Determining testing depth for a code change involves mapping the change type to appropriate validation rungs, such as crate tests, integration tests, and binary smokes. This process prevents over- or under-testing by matching the strategy to the change's impact.

What is the best way to classify confidence levels for code validation?

Classifying confidence levels for code validation requires a framework to honestly assess and report stability after executing testing rungs. It reports on executed rungs, test outcomes, unverified aspects, and the highest honest confidence level achieved.

When do I need integration tests versus watched live runs for module changes?

You need integration tests and watched live runs for module changes when the change impacts core systems like networking or user authentication. Selecting validation depth ensures that critical modules receive appropriate rungs beyond basic unit tests.

How do I report unverified aspects after running a test plan?

Reporting unverified aspects after running a test plan involves documenting executed rungs, test outcomes, and remaining gaps. This framework provides an honest confidence classification rather than assuming full coverage.

Does this validation planning approach work without external testing dependencies?

Yes, this validation planning approach works without external testing dependencies. It provides a structural framework to select validation steps and communicate confidence levels using your existing testing rungs and infrastructure.

Why does my test plan over-test minor code modifications?

Your test plan over-tests minor code modifications because it lacks a mapped validation ladder to scale testing depth. Mapping change types to appropriate rungs prevents unnecessary integration tests or watched live runs for low-impact modifications.