test-verification

Solid

Requires behavioral, failure-path, and durable-seam evidence for tests and review. Use when writing tests, reviewing test coverage, assessing behavioral test quality, or accepting high-risk behavior on test evidence.

AI & Automation 21 stars 2 forks Updated 3 days ago MIT

Install

View on GitHub

Quality Score: 81/100

Stars 20%
45
Recency 20%
100
Frontmatter 20%
70
Documentation 15%
100
Issue Health 10%
80
License 10%
100
Description 5%
100

Skill Content

# test-verification/SKILL.md ## Purpose Use this skill to write, evaluate, and verify tests that prove behavior rather than implementation details. ## Core Rule Tests prove behavior through public seams, not implementation internals. A test that breaks when you rename an internal variable without changing behavior is testing the wrong thing. A test that passes when the behavior is broken is worse than no test at all. ## Vertical Slice Discipline Write one test. Implement to pass it. Repeat. For every behavior change with testable logic, write the smallest targeted test and observe it fail for the missing behavior before changing the implementation. Do not write a broad suite for imagined internals before learning from one vertical slice. ```text WRONG (horizontal): RED: write all tests GREEN: write all implementation RIGHT (vertical): RED → GREEN: one test → its implementation → repeat ``` For a behavior change in existing code: ```text diagnose → write targeted behavior test → observe RED → implement narrow behavior → observe GREEN ``` For an extraction or refactor intended to preserve current behavior: ```text diagnose current behavior → add focused characterization test → observe PASS → move logic without changing behavior → observe PASS ``` A characterization test is not speculative: it pins behavior already present at a durable seam before logic moves. If the slice also changes behavior, characterize the current behavior first, then use a separate ...

Details

Author
Ezra144israel
Repository
Ezra144israel/governed-agent-skills
Created
1 months ago
Last Updated
3 days ago
Language
Python
License
MIT

Integrates with

Bundled in these plugins

Similar Skills

Semantically similar based on skill content — not just same category

AI & Automation Listed

tdd

Write the failing test before the implementation, for a single piece of code — red, green, refactor. A finer grain than the ledger's task-level verify.command (subagent-driven-development); use this INSIDE an implementer's work on one task, not as a replacement for the ledger.

5 Updated yesterday
bharat3645
Code & Development Solid

verify-behavior

Owns a cheapest-first three-tier verification ladder — Tier 1 syntactic (grep / ast-grep / read), Tier 2 semantic-no-execution (typecheck / build / lint), Tier 3 execution (run the covering test, or a minimal synthesized repro) — and reports the result as an evidence receipt (confirms / contradicts / ambiguous / null). It never scores; `confidence(code)` owns the number. Two consumer shapes: claim-verification (read-only, feeds `confidence(code)`) and change-verification (post-apply green/red gate). Called by `verification-receipt.md` (pr-reviewer Tier 2/3), `bug-fix-verifier`, `feature-pr-verifier`, and the `aw-executor` Phase 4 checks loop. Use when a finding or a change needs executed proof, not just a plausible-sounding claim. Triggers on "verify this claim", "does this actually happen at runtime", "prove this behavior", "run this to confirm", "/verify-behavior".

13 Updated yesterday
mthines
AI & Automation Listed

verification-beyond-tests

G7 — apply property-based testing, mutation testing, and formal verification as a stage-06d sub-stage. "Tests pass" becomes the floor; this skill raises the ceiling. Use after stage-06 PASS, when the diff contains pure functions / critical business logic / state machines worth verifying beyond examples.

6 Updated 5 days ago
telus-labs