Skip to content
Skills Library
Programming · Testing

verify-changes

/verify-changes

Use when changes in a worktree must be proven before a commit, PR or merge. Runs targeted local checks (format, lint, build, affected tests, runtime proof for user-visible changes), defers the rest to CI, fixes root causes and returns PASS, FAIL or INCONCLUSIVE with evidence. Triggers: verify-changes, /verify-changes, verify my changes, run the checks, is this ready to commit.

Repository
skills ↗
Licence
MIT
Last repository change
10.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 10.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when changes in a worktree must be proven before a commit, PR or merge. Runs targeted local checks (format, lint, build, affected tests, runtime proof for user-visible changes), defers the rest to CI, fixes root causes and returns PASS, FAIL or INCONCLUSIVE with evidence. Triggers: verify-changes, /verify-changes, verify my changes, run the checks, is this ready to commit.

Original author description

Use when changes in a worktree must be proven before a commit, PR or merge. Runs targeted local checks (format, lint, build, affected tests, runtime proof for user-visible changes), defers the rest to CI, fixes root causes and returns PASS, FAIL or INCONCLUSIVE with evidence. Triggers: verify-changes, /verify-changes, verify my changes, run the checks, is this ready to commit.

How it works

  1. Inputs
  2. 1. Find the checks
  3. 2. Add runtime proof for user-visible changes
  4. 3. Run
  5. 4. Fix failures
  6. 5. Review the diff
  7. 6. Report
Original SKILL.md headings · 62 lines, 890 words
SKILL.md preview
---
name: verify-changes
description: "Use when changes in a worktree must be proven before a commit, PR or merge. Runs targeted local checks (format, lint, build, affected tests, runtime proof for user-visible changes), defers the rest to CI, fixes root causes and returns PASS, FAIL or INCONCLUSIVE with evidence. Triggers: verify-changes, /verify-changes, verify my changes, run the checks, is this ready to commit."
---

# Verify changes

Prove that the current changes work, with evidence a reviewer can rerun. A check that did not run is not a pass.

## Inputs

- Worktree: the given path, else the current directory.
- Base: the given ref, else the merge base with the repository's default branch on `origin`.
- Task brief: an optional `task.md` (goal, acceptance criteria, artifacts directory). Without it, take the goal from the user's request.
- Previous report: an optional earlier `verify.md` for the same change. When given, rerun only the checks the changes since its `HEAD` can affect and carry the other results over, marked with the SHA they ran on.

Run nothing against production systems or live customer data.

## 1. Find the checks

Collect the local checks in this order of authority:

1. Repository instructions: `AGENTS.md`, `CLAUDE.md`, `CONTRIBUTING.md`, the pre-submit checklists they point to, and the directories on the path of each changed file. Checks they list for before a PR are required; conditional ones (for example "screenshot tests if UI changed") only when the condition holds.
2. Build files: package scripts, Gradle tasks, Makefile targets, Xcode schemes and similar, to find the commands and scope them to the changed modules.

When the instructions name no local checks, the default is: formatters and fast linters on the changed files, one build that compiles the changed code into the app, and the tests of the changed modules.

Read the CI configuration (such as `.github/workflows/`) only to learn what runs after the PR. Do not run a CI job locally because it exists in CI: release and variant builds, full test or screenshot suites, full end-to-end suites, slow whole-project static analysis, security scans (such as semgrep), license scans and similar jobs go to "Deferred to CI" in the report. Run one locally only when the instructions require it or it is the only way to prove the changed behavior.

Group the checks as: format, static checks (lint, types), build, tests. Scope tests and screenshot checks to the changed modules when the build allows it. Note any check you cannot find a command for.

## 2. Add runtime proof for user-visible changes

When the change alters what a user sees or does, look for a project verification skill (a skill named `verify-<app>`, or one the instructions name) for that surface. Run it for the affected flows only, never the whole end-to-end suite, and keep its evidence: screenshots, recordings, logs or responses. A change with no user-visible effect (refactoring, internal wiring) needs no runtime proof; its tests and CI's end-to-end jobs cover it.

No such skill, or no environment to run it (device, simulator, credentials): record runtime behavior as unverified, with the reason. Do not substitute a guess.

## 3. Run

- Run format first, on the changed files when the tool allows. Formatters rewrite files, so review what they changed and re-stage it when the repository requires formatted commits.
- Run slow commands so they do not block you, through the background facility the environment instructions name. Wait for the result instead of polling.
- For each check, record the command, exit code and, on failure, the relevant output lines.

## 4. Fix failures

1. Find the root cause. Fix it in the task's code, then rerun the failed check and every check the fix can affect.
2. A failure in code the change does not touch may be pre-existing. Check the same CI job on the base's latest commit; only if CI does not show it, run the check on the base locally. If it also fails there, report it as pre-existing with that evidence and do not fix it as part of this change.
3. Never make a check pass by skipping or deleting tests, weakening assertions, lowering thresholds, adding suppressions or disabling a check. That needs the user's explicit approval.
4. After 5 attempts on the same kind of failure, stop and return `FAIL` with the evidence.

## 5. Review the diff

1. Read `git status` and the full diff from the base, including untracked files.
2. Remove debug output, temporary files, stray artifacts and changes unrelated to the task.
3. Confirm that the change matches the goal and each acceptance criterion, that it contains no secrets or credentials, and that it overwrote no one else's work.

## 6. Report

Results apply to the final state of the tree. If you edit anything after a check, rerun the checks that edit can affect (a rename: the build and the tests of the touched modules), not the whole set.

- `PASS`: every required check ran on the final tree and passed, and the diff review found nothing left.
- `FAIL`: a required check fails after the retry limit, or the diff review found a problem you could not resolve.
- `INCONCLUSIVE`: everything that ran passed, but a required check or the runtime proof could not run. Name each one and why. Checks deferred to CI do not make the result `INCONCLUSIVE`.

Start the report with the `HEAD` SHA and the list of uncommitted files it covers. Then a table, `check | command | result | evidence`, followed by unverified items, pre-existing failures and "Deferred to CI" (each CI check left to the PR, one line each). When a task brief names an artifacts directory, also write the report to `verify.md` there.
Files in this package (2)
  • SKILL.md 6 KB
  • agents/openai.yaml 1 KB

Versions

RepositoryScoreLicence
This page · k0siara/skills100MIT
ben-ralston/reading-list100MIT
ben-ralston/apple-notes-graph100MIT
ben-ralston/tmux-agent-hq100MIT
guilhermevozniak/refactor-pilot-framework100MIT

Database snapshot: 13.11.2026 · package version fe22636459a6 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 95verify
    Run the full fuku verification loop (format, lint, vet, test, race, e2e, docs) before committing. Use when asked to verify changes, run lint, run tests, check that changes pass CI, or before any commit/push.
  • 100testing
    Run tests, verify changes, and collect diagnostics. Use when running tests, writing new tests, verifying code changes before commit, or collecting logs for debugging.
  • 100validating-pre-commit
    Runs quality gate checks before commit or push. Use when preparing to commit, reproducing CI failures locally, or validating changes pass all checks.
  • 90compiler-verify
    Use when you need to run all compiler checks (tests, lint, format) before committing. Detects whether TS or Rust code changed and runs the appropriate checks.
  • 100run-tests
    Use this skill when the user asks to "run tests", "test this", "check if tests pass", "cargo test", "run clippy", "lint this", "check formatting", "cargo fmt", "CI checks", "verify changes", "does this pass tests", "run the full check", "pre-commit check", or wants to verify…
  • 100coograph-verify
    Evidence-based completion check. Runs build, tests, and diagnostics itself and validates acceptance criteria, ending in a PASS / FAIL / INCOMPLETE verdict. Use when work is claimed complete.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.