task-verification-checkpoints

Verify output format, file coverage, and task alignment before completing

Quality

60%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./benchmarks/gdpval/skills/task-verification-checkpoints/SKILL.md

Task Verification Checkpoints

Before declaring a task as <COMPLETE>, perform these verification checks to ensure the deliverable matches requirements and prevents wrong-task completion.

Overview

This skill prevents common failures where agents:

Create outputs in wrong formats (PDF vs PPTX vs DOCX)
Skip processing some reference files
Drift from the actual task requirements

Three Critical Checkpoints

Checkpoint 1: Output Format Verification

Question: Does the output file format match task requirements?

Actions:

Re-read the task prompt for explicit format requirements
Check file extensions of all output files
Verify the actual file type matches the extension
Confirm against any format specifications (e.g., "revised PDF report")

Example validation:

def verify_output_format(task_prompt, output_files):
    """Check if output format matches task requirements."""
    required_format = extract_format_requirement(task_prompt)  # e.g., 'pdf', 'pptx'
    
    for f in output_files:
        actual_ext = f.split('.')[-1].lower()
        if actual_ext != required_format:
            return False, f"Expected .{required_format}, got .{actual_ext}"
    
    return True, "Format verified"

Checkpoint 2: Reference File Coverage

Question: Were ALL reference/input files processed?

Actions:

List all files mentioned in the task as inputs
Confirm each was read/analyzed/used (check file access logs)
Document which content from each file contributed to output
Flag any unprocessed reference files

Example validation:

def verify_reference_coverage(task_files, accessed_files):
    """Ensure all reference files were actually processed."""
    missing = set(task_files) - set(accessed_files)
    if missing:
        return False, f"Unprocessed files: {missing}"
    return True, "All references processed"

Checkpoint 3: Task Alignment Verification

Question: Does the deliverable address the ACTUAL task prompt?

Actions:

Re-read the original task description verbatim
Compare output purpose against stated task goal
Check for scope creep or task drift
Verify the output solves the stated problem (not a different one)

Example validation:

def verify_task_alignment(task_prompt, output_description):
    """Confirm output addresses the actual task."""
    task_verbs = extract_action_verbs(task_prompt)  # e.g., 'review', 'revise', 'create'
    output_verbs = extract_action_verbs(output_description)
    
    if not set(task_verbs).issubset(set(output_verbs)):
        return False, "Output actions don't match task requirements"
    
    return True, "Task alignment verified"

Pre-Completion Checklist

Execute this checklist before marking ANY task complete:

def pre_completion_verification(task_prompt, output_files, reference_files):
    """
    Complete verification before declaring task done.
    Returns (success, message) tuple.
    """
    checks = []
    
    # Check 1: Format
    format_ok, format_msg = verify_output_format(task_prompt, output_files)
    checks.append(('Format', format_ok, format_msg))
    
    # Check 2: Coverage
    coverage_ok, coverage_msg = verify_reference_coverage(reference_files, get_accessed_files())
    checks.append(('Coverage', coverage_ok, coverage_msg))
    
    # Check 3: Alignment
    alignment_ok, alignment_msg = verify_task_alignment(task_prompt, get_output_summary())
    checks.append(('Alignment', alignment_ok, alignment_msg))
    
    # Report results
    all_passed = all(ok for _, ok, _ in checks)
    
    if not all_passed:
        print("❌ VERIFICATION FAILED - Do not mark complete")
        for name, ok, msg in checks:
            status = "✓" if ok else "✗"
            print(f"  {status} {name}: {msg}")
        return False, "Verification failed"
    
    print("✓ All verification checkpoints passed")
    return True, "Ready for completion"

When to Apply

Use this skill whenever:

Creating deliverables from input/reference files
Task specifies output format requirements
Multiple files must be processed/analyzed
Task involves transformation, revision, or synthesis
Always before any <COMPLETE> declaration

Common Failure Modes to Catch

Failure Type	Example	Prevention
Format mismatch	Created PPTX when PDF requested	Checkpoint 1
Incomplete coverage	Skipped Photographs.zip	Checkpoint 2
Task drift	Created new report instead of revising existing	Checkpoint 3
Assumption errors	Assumed format without verification	All checkpoints

Quick Reference

Before <COMPLETE>:
  □ Output format matches requirements?
  □ All reference files processed?
  □ Deliverable addresses actual task?
  
If ANY box unchecked → Do NOT complete, fix first.

Repository: HKUDS/OpenSpace
Path: benchmarks/gdpval/skills/task-verification-checkpoints/SKILL.md
Commit: c5a9c4b

Last updated: 2 days ago
First committed: 14 days ago

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.