Validation Contract logo

Validation Contract

Community
peterbamuhigire
validation-contract

Use when authoring or normalising a specialist skill, or preparing to ship a feature or release — defines the seven evidence categories every specialist skill must declare against and provides the canonical Release Evidence Bundle template. The contract spine that turns scattered validation skills into a coherent ship-readiness check.

Overview

Publisherpeterbamuhigire
Repositorychwezi-dev-engine
Skill namevalidation-contract
Stars
29
Forks
6
Bundled files
4
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 4 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by peterbamuhigire on GitHub. Read the source before you install it.

Installation

Install the Validation Contract AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/peterbamuhigire/chwezi-dev-engine/tree/main/skills/architecture/validation-contract
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/peterbamuhigire/chwezi-dev-engine.git /tmp/chwezi-dev-engine
mkdir -p .claude/skills
cp -r /tmp/chwezi-dev-engine/skills/architecture/validation-contract .claude/skills/validation-contract
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Validation Contract in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Validation Contract on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Validation Contract is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Validation Contract

Acknowledgement: Shared by Peter Bamuhigire, techguypeter.com, +256 784 464178.

Use When

  • Authoring a new specialist skill and deciding which validation evidence it should produce.
  • Normalising an older specialist skill against the current house style.
  • Preparing a feature or release for ship and assembling the Release Evidence Bundle.
  • Reviewing a PR that claims a feature is production-ready.

Do Not Use When

  • The work is purely local, experimental, or explicitly throwaway with no path to production.
  • The skill being authored is a baseline, process, or pure index skill. Those do not declare evidence.
  • The task is unrelated to validation planning or shipping readiness.

Required Inputs

  • The specialist skill or feature being validated, including its intended scope and risk tier.
  • Access to the repository's existing validation skills (advanced-testing-strategy, vibe-security-skill, observability-monitoring, etc.) as the source of category-specific "how to validate" content.
  • Awareness of the 14 canonical artifact templates in skill-composition-standards/references/ so evidence rows can cite existing formats.

Workflow

  • Identify whether the skill or feature in scope is specialist (declares evidence) or baseline/process (does not).
  • For specialist skills: map each artifact the skill produces to one of the seven evidence categories.
  • For releases: produce a Release Evidence Bundle that links concrete artifacts under each of the seven categories, using N/A — <reason> only where an entire category legitimately does not apply.
  • Cross-check risk tier guidance before permitting any N/A in high-risk releases.

Quality Standards

  • Every specialist skill that produces validation evidence declares at least one evidence category with a concrete artifact reference.
  • Evidence declarations cite existing artifact templates where possible instead of inventing new formats.
  • Release Evidence Bundles never carry empty cells. Every cell links evidence or carries an N/A — <reason> line.

Anti-Patterns

  • Declaring every category on every skill "just in case". This kills the signal.
  • Writing prose validation notes instead of linking concrete artifacts in a Release Evidence Bundle.
  • Permitting unjustified N/A on Correctness, Security, Data safety, Operability, or Release evidence in high-risk releases.
  • Treating the Release Evidence Bundle as a retrospective summary written after ship. It is produced before ship.

Outputs

  • A specialist skill with a validated ## Evidence Produced section declaring one or more of the seven categories.
  • A Release Evidence Bundle in the project's docs/ tree linking evidence for every applicable category at ship time.
  • Clear N/A — <reason> annotations for non-applicable categories, with risk-tier-aware justification.

References

The three repository-wide contracts

The repository is held together by three contracts, each codified in a baseline skill:

  1. House-style contract — every skill follows the same shape. Source: skill-composition-standards, Standard 1.
  2. Inputs/Outputs contract — every skill declares the artifacts it consumes and produces. Source: skill-composition-standards, Standard 2.
  3. Evidence contract — every specialist skill declares which of seven fixed validation categories its artifacts contribute to, and every release produces a Release Evidence Bundle. Source: this skill.

The three contracts stack. A skill that meets Standard 1 but skips Standard 2 or 3 is not repository-grade.

The seven evidence categories

#CategoryWhat the evidence proves
1CorrectnessBehaviour matches spec; tests cover risk surface; contracts hold.
2SecurityThreat model exists; scans clean; secrets handled; auth/authorisation verified.
3Data safetySchema integrity; migration safety; backup, retention, and PII handling.
4PerformanceBudgets met; load profile understood; query plans acceptable.
5OperabilitySLOs defined; runbook exists; observability wired; rollback plan ready.
6UX qualityAccessibility pass; design audit; content/UX-writing review; AI slop check.
7Release evidenceChange record; migration plan; rollout/rollback log; post-deploy verification.

The taxonomy is closed. Adding an eighth category requires editing this skill, not silently extending it elsewhere. Full definitions and indicative contributing skills live in references/evidence-categories.md.

Declaration mechanic

Specialist skills add a ## Evidence Produced section to their SKILL.md, between ## Outputs and ## References:

markdown
## Evidence Produced

| Category | Artifact | Format | Example |
|----------|----------|--------|---------|
| Security | Threat model | Markdown doc per `skill-composition-standards/references/threat-model-template.md` | `docs/security/threat-model-checkout.md` |
| Operability | Runbook | Markdown doc per `skill-composition-standards/references/runbook-template.md` | `docs/runbooks/payment-failures.md` |

Rules

  • A specialist skill that produces validation evidence MUST declare at least one row.
  • Each row's Category value MUST be one of the seven canonical names (case-sensitive).
  • Each row's Format field MUST reference an existing template or define its own format inline in the same SKILL.md.
  • A specialist skill MAY contribute to multiple categories.
  • Baseline skills, process skills, and pure index/orchestration skills MUST NOT declare.

Worked examples live in references/declaration-form.md.

Specialist vs exempt skills

A skill is "specialist" for the purposes of this contract when it:

  • Produces concrete project artifacts (code patterns, schemas, configs, documents).
  • Is loaded for a specific domain or platform problem rather than as a baseline frame.

Skills exempt from declaring (non-exhaustive):

  • world-class-engineering, skill-composition-standards, validation-contract itself.
  • system-architecture-design, world-class-engineering, git-collaboration-workflow.
  • feature-planning, and spec authoring in project-requirements (../../sdlc-meta/project-requirements/references/spec-architect.md).
  • All superpowers:* skills.

When a skill straddles the line, the default is declare. False positives are cheaper than silent omissions.

The Release Evidence Bundle

When a feature or release is ready to ship, the reviewer produces a single fillable document — the Release Evidence Bundle — that links to the concrete artifacts satisfying each of the seven categories.

  • Template: references/release-evidence-bundle-template.md.
  • N/A semantics: permitted only with a reason on the same line. An empty cell is not acceptable.
  • Risk tier guidance:
    • Low risk — internal tools, docs, non-user-facing scripts. Typical bundle has 3-4 categories live.
    • Medium risk — user-facing feature, single-tenant. All 7 categories addressed; some may be N/A with reason.
    • High risk — multi-tenant data, payments, auth, external APIs, AI features. All 7 categories live; no N/A permitted on Correctness, Security, Data safety, Operability, or Release evidence.

Strictness

  • The contract uses MUST, MAY, MUST NOT in the RFC 2119 sense.
  • Mechanical enforcement is out of scope for this skill. It lands separately as a CI contract-gate hook that will:
    • parse ## Evidence Produced tables and warn on missing or invalid categories.
    • parse Release Evidence Bundles and warn on empty cells or unjustified N/A.
  • Authoring with binding language now means the CI hook is a parser and CI integration only, not a policy debate.

Integration with existing skills

The rollout in references/integration-rollout.md lists every edit made to other skills when this skill was introduced. Future edits that touch this contract should update that file.

Companion Skills

Risk-scaled simplification gate

Short code or fewer dependencies is not an acceptance criterion by itself. For high-risk changes, the Release Evidence Bundle must identify negative or mutation evidence that would fail if authorisation, boundary validation, transaction integrity, retry/idempotency, recovery, audit logging, accessibility state, or observability were removed. Low-risk read-only changes may use a smaller sufficient set when the record names the excluded categories and why they do not apply. This is a risk-scaled rule, not a universal one-test limit.

Inputs

ArtefactRequired?Purpose
Claimed release evidenceyesEstablish what can be verified
Category requirementsyesDetermine mandatory proof

Capability contract

Read and search are required to trace evidence producers and consumers. Execution is required only for machine-verifiable gates. Editing is permitted only when contract repair is authorised.

Degraded mode

Fallback when evidence cannot be executed or retrieved: mark the category unverified; never convert missing evidence into a pass.

Decision rules

Evidence stateRelease statusAction
Required category has verified passing evidencePass categoryAttach artefact to bundle
Evidence exists but is stale or incompleteConditionalRefresh before release
Required evidence is missing or failingBlockDo not ship

Domain anti-patterns

  • Accepting a prose claim as test evidence. Fix: require the named artefact or command result.
  • Reusing stale evidence after relevant code changed. Fix: rerun the producing check.
  • Marking inaccessible evidence as passed. Fix: record unverified.
  • Allowing one category to substitute for another. Fix: satisfy each mandatory category independently.
  • Shipping an incomplete evidence bundle. Fix: block until required artefacts and provenance are present.

Companion skills

  • skill-composition-standards — Standards 1 and 2. Load this before validation-contract.
  • world-class-engineering — repository production-readiness bar. This contract makes the evidence of meeting that bar a first-class artifact.
  • Category-specific skills — the source of truth for how to validate within each category (see references/evidence-categories.md).

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Validation Contract AI skill do?

Use when authoring or normalising a specialist skill, or preparing to ship a feature or release — defines the seven evidence categories every specialist skill must declare against and provides the canonical Release Evidence Bundle template. The contract spine that turns scattered validation skills into a coherent ship-readiness check.

Why use Validation Contract on TypingMind?

Because you install it once and use it with any model. Validation Contract is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Validation Contract in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/peterbamuhigire/chwezi-dev-engine/tree/main/skills/architecture/validation-contract. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Validation Contract?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Validation Contract?

As many as you like. As long as a model supports skills, you can use Validation Contract with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Validation Contract AI skill free?

Yes. It is published on GitHub by peterbamuhigire under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇