proof-of-work

name	proof-of-work
description	Enforces validation and evidence before claiming work complete. Use before declaring implementation done, creating a PR, or submitting deliverables for review.
alwaysApply	false
category	workflow-methodology
tags	["validation","testing","proof","definition-of-done","acceptance-criteria"]
dependencies	[]
tools	[]
usage_patterns	["completion-validation","acceptance-testing","proof-generation"]
complexity	intermediate
model_hint	standard
estimated_tokens	3000
modules	["modules/acceptance-criteria.md","modules/anti-cargo-cult.md","modules/evidence-logging.md","modules/independent-verification.md","modules/iron-law-enforcement.md","modules/output-contracts.md","modules/red-flags.md","modules/retry-protocol.md","modules/todowrite-patterns.md","modules/validation-protocols.md","modules/verifier-integrity.md"]
role	library

"It looks correct" is not "I verified it works." Proof-of-work is the discipline of closing that gap: reproducible evidence before any claim that a task is done.

Proof of Work

When NOT To Use

• Planning before implementation (use imbue:karpathy-principles)
• Deciding whether the work is in scope (use imbue:scope-guard)

Table of Contents

• Overview
• The Iron Law
• Usage Standards
• Validation Protocol
• Integration
• Validation Checklist
• Red Flag Self-Check
• Exit Criteria

Overview

The "Proof of Work" methodology prevents premature completion claims by requiring technical verification before stating that a task is finished. For example, instead of assuming an LSP configuration functions after a restart, we verify that the server starts and that tools respond to queries. This approach confirms the solution works before the user attempts validation.

Before claiming completion, provide reproducible evidence of the solution's performance and address edge cases. All claims must be backed by actual command output captured in the current environment.

The Iron Law

NO IMPLEMENTATION WITHOUT A FAILING TEST FIRST NO COMPLETION CLAIM WITHOUT EVIDENCE FIRST NO CODE WITHOUT UNDERSTANDING FIRST

The Iron Law prevents testing from becoming a perfunctory exercise. If an implementation is planned before tests are written, the RED phase fails to drive the design. Understand the technical rationale for an approach and its limitations before declaring it done. Before writing code, document evidence of the failure being addressed and confirm that tests are driving the implementation.

Verification and TDD Workflow

Verify the fundamentals of the implementation and the reasons for choosing it over alternatives. Identify where a solution might fail rather than stating it should always work. The TDD cycle follows these mandatory steps:

1. RED: Write a failing test before implementation.
2. GREEN: Create a minimal implementation that passes the test.
3. REFACTOR: Improve the code without changing its behavior.

Iron Law Self-Check