Verification Before Completion

SkillProductivity

The verification skill is a productivity tool for AI agents that makes an agent prove a code change actually works before it claims the task is complete. It requires the agent to run real verification commands, such as compiles, tests, lints, and type checks, and to paste the passing output as evidence. Vague claims like "should work" or "looks correct" are rejected as proof.

Connect your AI Use it in a pipeline

Then ask your AI: use the Verification Before Completion skill

Details

Instructions available. Your AI can read the instructions. Execution depends on the setup they require.

Account requirements not reviewed. Check the skill instructions before use; Ahel provides instructions and does not run this skill.

No other account needed.

Make sure the agent can run shell commands in the project environment.

What your AI can do with it

Defines verification commands for schema, Java, Python, and frontend changes
Requires running compiles, tests, lints, and type checks before completion
Requires pasting actual passing output as evidence
Rejects "should work" and "looks correct" claims as proof
Provides an evidence format for reporting verification results

Getting started

Make sure the agent can run shell commands in the project environment.
Add the verification skill to the agent's available skills.
Identify the type of change being made, such as schema, Java, Python, or frontend.
Have the agent run the verification commands listed for that change type.
Require the agent to paste the passing output before reporting the task complete.

What this skill tells your AI

The instructions your AI receives, as published by open-metadata/openmetadata in skills/verification/SKILL.md and read by Ahel’s review.

No completion claims without fresh verification evidence.

Core Rule

Never say "done", "should work", "looks correct", or "this fixes it" without running the verification commands and showing the output.

Verification by Change Type

Schema Changes (`openmetadata-spec/`)

# 1. Regenerate models
make generate

# 2. Verify Java compilation
mvn test-compile -pl openmetadata-spec,openmetadata-service

# 3. Verify Python models
source env/bin/activate && cd ingestion
python -c "from metadata.generated.schema.entity.services.connections.<module> import <Model>; print('OK')"

# 4. If connection schema: verify UI schema resolution
cd openmetadata-ui/src/main/resources/ui && yarn parse-schema

Java Backend Changes

# 1. Format
mvn spotless:apply

# 2. Compile
mvn test-compile -pl <module>

# 3. Run relevant tests
mvn test -pl <module> -Dtest=<TestClass>

# 4. Unit tests + integration tests the diff impacts (PR CI runs no ITs; see java-affected-tests)
make java_affected_run

Python Ingestion Changes

source env/bin/activate && cd ingestion

# 1. Format (apply) then lint check (verify)
make py_format
make py_format_check

# 2. Type check
make static-checks

# 3. Run unit tests
python -m pytest tests/unit/<relevant_test>.py -v

# 4. For connector changes: run connector-specific tests
python -m pytest tests/unit/topology/<service_type>/ -v

Frontend Changes

cd openmetadata-ui/src/main/resources/ui

# 1. Lint
yarn lint

# 2. Type check
npx tsc --noEmit

# 3. Run unit tests
yarn test <path/to/changed/component>

# 4. For significant UI changes: run Playwright tests
yarn playwright:run --grep "<relevant test>"

Evidence Format

When reporting completion, include:

## Verification Results

### Commands Run
1. `mvn spotless:apply` — completed, no formatting changes needed
2. `mvn test -pl openmetadata-service -Dtest=MyTest` — 5/5 tests passed
3. `yarn lint` — no errors

### Test Output
[paste relevant test output showing PASS]

What Counts as Evidence

Test runner output showing PASS
Build output showing SUCCESS
Lint/format output showing no errors
API response showing expected data
Screenshot or description of UI rendering correctly

What Does NOT Count as Evidence

"I reviewed the code and it looks correct"
"This follows the same pattern as X, so it should work"
"The logic is straightforward"
"I've made similar changes before"
No output at all — just claiming it's done

Signals

GitHub stars: 15k
Forks: 2k
Last commit: Oct 2026

Questions

What counts as evidence?: Test runner output showing PASS, build output showing SUCCESS, lint or format output showing no errors, an API response showing expected data, or a screenshot or description of UI rendering correctly.
What does not count as evidence?: "I reviewed the code and it looks correct", "this follows the same pattern as X, so it should work", "the logic is straightforward", "I've made similar changes before", or no output at all.

Advanced

Item type: skill
Key: verification-open-metadata
Source: github.com/open-metadata/openmetadata

github.com/open-metadata/openmetadata