Skip to content
Skills Library
Programming · Testing

validation

/validation

Pipeline phase skill for state `validation`. Use when current_state is validation.

Repository
agentic-swe ↗
Licence
MIT
Last repository change
21.10.2026

Assessment and security

90/ 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.
Content25 / 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
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 21.10.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

Pipeline phase skill for state `validation`. Use when current_state is validation.

Original author description

Pipeline phase skill for state `validation`. Use when current_state is validation.

How it works

  1. Mission
  2. Persona
  3. Procedure
  4. Reflection on Failure
  5. Inputs
  6. Required Output
  7. Doubt Cycle (Optional)
  8. Common Rationalizations
  9. Red Flags
  10. Failure Protocol
Original SKILL.md headings · 95 lines, 788 words
SKILL.md preview
---
name: validation
description: "Pipeline phase skill for state `validation`. Use when current_state is validation."
metadata:
  tier: "L2"
  eval_status: "evaluated"
  eval_ref: "bench/corpus/oracle-version-check"
  version: "1.0.0"
  provenance: "generate-skills"
  kind: "phase"
  source: "phases/validation.md"
---

# Validation

## Mission

Run integrated validation and classify the outcome as approved, rejected, or blocked.

## Persona

Release gatekeeper — trusts execution evidence over reasoning, classifies failures precisely.

## Procedure

0. If on the lean track (`state.json.pipeline.lean_track_eligible == true`):
   - Check that `implementation.md` contains test evidence (command + output + result).
   - If the change is behavioral (not documentation-only) and no test evidence exists, classify as `failed` with reason: "missing test evidence for behavioral change".

1. Run the strongest available integrated checks per `${CLAUDE_PLUGIN_ROOT}/references/verification-standard.md` — every claim in the resulting artifact must map to captured executable evidence (command, output, exit code). Hedging language in conclusions is not acceptable; if a check cannot be run, state that explicitly instead.
   - Invoke `/test-runner` for test execution
   - Invoke `/lint` for lint and format checks
   - Run build and typecheck commands directly
2. If `implementation.md` includes **`## Capability gaps`**, note in `validation-results.md` whether residual risk is acceptable or whether a follow-up task (custom subagent under `${CLAUDE_PLUGIN_ROOT}/agents/subagents/custom/`, or org docs) is recommended. Do not fail validation solely for documented gaps unless the change is unsafe to ship without that expertise.
3. Capture exact commands and decisive outputs.
4. Classify the result:
   - `approved`: all checks pass
   - `failed`: code defects found
   - `blocked`: environment or infrastructure issue
5. If blocked, identify the blocking layer (local env, missing secret, flaky infra, unsupported path).
6. Recommend whether to return to implementation or escalate.
7. Retry blocked validation only within the configured budget.
8. When classification is **`approved`** and transitioning to **`pr-creation`** or **`completed`**, the work engine auto-captures a descent procedure from `validation-results.md` (L1 on first success; L0 after two successes or with `--auto-l0`). Optionally run manually: `agentic-swe work descent-capture --work-dir .worklogs/<id>`.

## Reflection on Failure

When classification is `failed`, append a structured entry to `.worklogs/<id>/reflection-log.md`:

- **What failed**: which checks failed and exact output
- **Root cause**: hypothesis for why the failure occurred
- **Strategy change**: what the implementation should change to address the failure

Before retrying or returning to implementation, consult `${CLAUDE_PLUGIN_ROOT}/references/debugging-playbook.md` for systematic root-cause analysis. Reproduce the failure, trace data flow, and form a single hypothesis before attempting a fix. Do not retry blindly.

## Inputs

- `.worklogs/<id>/implementation.md`
- `.worklogs/<id>/permissions-changes.md` (if exists)
- Repository build/test/lint configuration

## Required Output

Write `.worklogs/<id>/validation-results.md` following `${CLAUDE_PLUGIN_ROOT}/templates/artifact-format.md`, with:

- commands run and observed output summary
- classification: `approved`, `failed`, or `blocked`
- confidence, retry count
- recommended next state

Apply `${CLAUDE_PLUGIN_ROOT}/templates/evidence-standard.md` throughout.

## Doubt Cycle (Optional)

When a validation claim **cannot be trivially verified** by test output alone (e.g. "this is safe under concurrent access", "performance meets SLA"), invoke a Doubt-Driven Verification cycle per `${CLAUDE_PLUGIN_ROOT}/references/doubt-driven-verification.md`:

1. Name the CLAIM (the validation assertion under scrutiny).
2. EXTRACT the claim + evidence artifact + contract.
3. DOUBT — spawn a fresh-context adversarial reviewer using `${CLAUDE_PLUGIN_ROOT}/agents/prompts/adversarial-reviewer-prompt.md`. Do NOT pass the CLAIM.
4. RECONCILE findings (contract-misread / actionable / trade-off / noise).
5. STOP after trivial findings, 3 cycles, or user override.

Increment `state.json.counters.doubt_cycles` for each cycle.

## Common Rationalizations

| Rationalization | Reality |
|---|---|
| "All the logic looks correct — validation is a formality." | Validation exists because narrative confidence is unreliable. Code that "looks correct" fails in production when assumptions about state, input, or environment are wrong. |
| "That test failure is flaky — I've seen it before." | Flaky tests require investigation, not dismissal. A failure classified as flaky without evidence of the flake mechanism is an uninvestigated failure. |
| "The build passed, so the change is safe to ship." | Build success proves compilation, not correctness. Type checks and lint passes do not exercise runtime behavior, integration boundaries, or data-dependent paths. |
| "We already tested this during implementation." | Implementation-time tests run in a developer context. Validation re-runs in an integrated context to catch environment assumptions, missing configuration, and interaction effects. |
| "The lint warnings are pre-existing — not our problem." | Pre-existing warnings mixed with new changes obscure signal. If the change touches a file with warnings, determine whether the change worsened them. |

## Red Flags

- Validation artifact classifies result as "approved" but lists commands that were not actually run.
- Test failures are classified as "flaky" without citing prior flake evidence or reproduction attempts.
- The validation ran only a subset of the test suite without justifying why unrelated suites were excluded.
- No build or typecheck command appears in the validation evidence despite code changes.
- Classification is "blocked" but no specific blocker (secret, environment, infrastructure) is identified.
- Capability gaps from `implementation.md` are not mentioned in the validation assessment.

## Failure Protocol

- if execution evidence is weak, say so
- if a failure is flaky, explain why you believe it is flaky

Versions

RepositoryScoreLicence
This page · agentic-swe/agentic-swe90MIT
mtwuser/zero-cloud-gravity100MIT
ruujOnChain/HedgeFund-Skills100MIT
hamzabellouch/agent-skills100MIT
minhuw/claude-writer100MIT
richard-kim-79/archora-skills100MIT
matteocervelli/llms95MIT
openai/codex-security90Apache-2.0

Database snapshot: 13.11.2026 · package version a163295762cf (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

  • 90verification
    Pipeline phase skill for state `verification`. Use when current_state is verification.
  • 90escalate-validation
    Pipeline phase skill for state `escalate-validation`. Use when current_state is escalate-validation.
  • 95n8n-validation-expert
    Interpret validation errors and guide fixing them. Use when encountering validation errors, validation warnings, false positives, operator structure issues, or need help understanding validation results. Also use when asking about validation profiles, error types, or the validation loop process.
  • 90platform-validation-rule-generate
    Use this skill when users need to create, modify, or validate Salesforce Validation Rules. Trigger when users mention validation rules, field validation, data quality rules, formula validation, error messages, or validation logic. Also use when users encounter validation errors,…
  • 95aspnet-validation
    ASP.NET Core validation with FluentValidation, Data Annotations, and model validation. Covers custom validators and validation pipeline. USE WHEN: user mentions "FluentValidation", "Data Annotations", "model validation", ".NET validation", "input validation", "validator",…
  • 100validation-first
    Validation-first development. Use when developing with formal state machine specifications, invariants, and temporal properties before writing implementation code.

Feedback and reports

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