verify-skill

Name: verify-skill
Availability: InStock
Author: mkusaka

Verify code changes by manually observing runtime behavior before commit.

7|Updated Mar 8, 2026

Search Tags:#bug prevention #developer workflow #commit validation #code verification #runtime observation

Ready to run

npx skills add https://github.com/mkusaka/ccskills --skill verify-skill-mkusaka

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: verify-skill
Source: https://github.com/mkusaka/ccskills/tree/main/skills/verify-skill
Command: npx skills add https://github.com/mkusaka/ccskills --skill verify-skill-mkusaka

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

The Skill simplifies the process of verifying code changes, providing an opinionated workflow to validate the actual runtime behavior of code modifications.

Core Features & Use Cases

Opinionated Verification: Offers a structured process to manually observe code behavior.
End-to-End Observation: Requires executing code end-to-end and not just tests.
Use Case: Before committing a change, this Skill ensures the new code operates as expected, reducing the risk of introducing bugs.

Quick Start

To verify your latest commit, use the verify-skill and specify the commit range with git diff HEAD^1 HEAD.

Frequently Asked Questions about verify-skill

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

FAQPage Schema

How do I verify code changes before committing to prevent bugs?▼

Code verification before committing involves manually observing runtime behavior in end-to-end execution scenarios. This opinionated workflow requires executing application flows manually or via provided verifier skills to validate changes and reduce the risk of introducing bugs.

What's the best way to validate runtime behavior of a git diff?▼

Validating runtime behavior of a git diff requires end-to-end execution observation rather than just running tests. Specify the commit range using `git diff HEAD^1 HEAD` and manually observe the application flows to ensure the new code operates as expected.

Does pre-commit code verification require running automated tests?▼

Pre-commit code verification requires end-to-end execution observation rather than just running automated tests. It focuses on manually observing runtime scenarios to validate actual behavior, making it suitable for integration with existing CI workflows.

Can I integrate manual code observation into existing CI workflows?▼

Manual code observation can be integrated into existing CI workflows for pre-commit validation. This opinionated approach requires executing application flows manually or via provided verifier skills to observe end-to-end runtime behavior before integration.

Why does end-to-end execution observation prevent bugs better than unit tests alone?▼

End-to-end execution observation prevents bugs by requiring manual observation of code in actual runtime scenarios, validating real behavior rather than isolated components. This ensures new code operates as expected across complete application flows before committing.