What is verify-output?

The Verify Output skill is a specialized pattern designed to ensure Claude's generated outputs strictly adhere to predefined JSON schemas. By implementing a 'validate-before-write' workflow, it prevents structural errors, enforces mandatory fields like reflections and knowledge updates, and guarantees that all agent communications are valid, compact, and ready for downstream processing. This skill is essential for maintaining data integrity in multi-agent systems and automated workflows.

When should I use verify-output?

verify-output is useful in the following scenarios: • Automated Schema Validation: Verifying that agent-generated JSON files (such as demand reports, technical designs, or task outputs) match specific architectural requirements before they are finalized. • Pre-completion Quality Checks: Utilizing a temporary file write-and-validate pattern to catch missing required fields or invalid enum values, preventing broken data from reaching the production environment. • Standardizing Agent Communication: Enforcing compact JSON formatting and mandatory metadata fields across different agent roles to maintain system-wide consistency and interoperability. • Self-Correction Loops: Providing agents with specific validation error feedback, enabling them to automatically fix and retry output generation to achieve 100% schema compliance.

name	verify-output
description	Pattern for verifying your output matches required schema before completing. Use before writing final output to ensure validity.
allowed-tools	Read, Bash

Verify Output Skill

Pattern for ensuring outputs match required schemas using automated validation.

When to Use

Before writing final output file
After completing a task
When producing structured JSON output

Quick Reference

Validate before writing:

./scripts/validate.sh <schema_name> <file_path>

Available Schemas

Schema	Used By	Output Path
`demand`	PM	`memory/reports/demand.json`
`design`	Architect	`memory/reports/designs/*.json`
`task-output`	Implementer	`memory/tasks/*/output.json`
`verification`	Verifier	`memory/tasks/*/verification.json`
`reflection`	Reflector	`memory/reflections/*.json`
`evolution-proposal`	Evolver	`memory/evolution/*.json`
`contract`	Executor	`memory/contracts/*.json`

Validation Process

Step 1: Determine Your Schema

Based on your agent role:

PM agent          → demand.schema.json
Architect agent   → design.schema.json
Implementer agent → task-output.schema.json
Verifier agent    → verification.schema.json
Reflector agent   → reflection.schema.json
Evolver agent     → evolution-proposal.schema.json

Step 2: Write Output to Temp Location

Write(memory/tasks/{id}/output.json.tmp, content)

Step 3: Validate

./scripts/validate.sh task-output memory/tasks/{id}/output.json.tmp

Step 4: If Valid, Move to Final Location

mv memory/tasks/{id}/output.json.tmp memory/tasks/{id}/output.json

Step 5: If Invalid, Fix and Retry

Common validation errors and fixes:

Error	Fix
`'X' is a required property`	Add the missing field
`'Y' is not one of ['a', 'b']`	Use valid enum value
`'Z' is not of type 'array'`	Wrap value in array: `[value]`
`Additional properties not allowed`	Remove extra fields

Output Format: Compact JSON

All agent outputs MUST be compact JSON (single line, no extra whitespace):

{"task_id":"001","status":"pre_complete","knowledge_updates":[],"reflection":{"what_worked":[],"what_failed":[],"patterns_noticed":[]}}

Mandatory Fields (All Agents)

Every output MUST include:

{"knowledge_updates":[{"category":"codebase","content":"string","confidence":"certain"}],"reflection":{"what_worked":["string"],"what_failed":["string"],"patterns_noticed":["string"]}}

Or empty arrays if no updates:

{"knowledge_updates":[],"reflection":{"what_worked":[],"what_failed":[],"patterns_noticed":[]}}

Valid values:

category: "codebase" | "convention" | "decision" | "gotcha"
confidence: "certain" | "likely" | "uncertain"

Pre-Write Validation Pattern

Recommended pattern for agents:

1. Construct output object in memory
2. Write to {output_path}.tmp
3. Run: ./scripts/validate.sh {schema} {output_path}.tmp
4. IF validation passes:
     → mv {output_path}.tmp {output_path}
     → Log: "Output validated and written"
5. ELSE:
     → Read validation errors
     → Fix output object
     → Retry from step 2
     → Max 3 retries, then report validation failure

Common Mistakes

Forgetting knowledge_updates (even if empty array)
Forgetting reflection fields
Using invalid enum values (check schema for allowed values)
Missing required nested fields
Wrong type (string instead of array, etc.)
Using YAML instead of JSON
Pretty-printing JSON (use compact format)

Principles

Validate before write - Never output invalid data
Schema is law - Missing fields = rejection by executor
Empty is valid - "knowledge_updates":[] is okay
Fail fast - Catch errors before they propagate
Compact JSON - Single line, no formatting

verify-output

When & Why to Use This Skill

Use Cases