Writing Validate

Announce: "Using writing-validate (Phase 3.5) to validate draft sections against PRECIS.md claims."

Contents

• The Iron Law of Validation
• Red Flags - STOP Immediately
• Purpose
• Validation Levels
• The Process
• Classification
• VALIDATION.md Template
• Gate
• Rationalization Prevention
• Drive-Aligned Framing
• Phase Transition

Claim Validation Against PRECIS.md

Phase between draft and review. Maps every PRECIS.md claim to a draft section and verifies coverage. This is the writing equivalent of DS's DQ validation — without it, review checks quality on prose that may not even address the argument.

NO REVIEW WITHOUT CLAIM VALIDATION. This is not negotiable.

writing-review MUST NOT start until .planning/VALIDATION.md confirms all PRECIS claims are addressed in drafts. Validation is the writing equivalent of test coverage — without it, review is theater.

Purpose

This phase sits between writing-draft and writing-review. It runs the same constraint checks that review uses — from the writing constraints, the domain skill, and ai-anti-patterns — but earlier, so gaps are caught before review begins. Review should NOT be discovering missing claims, broken expansion hierarchy, or AI writing smell.

The constraint checks ARE the validation. This phase doesn't invent new checks — it systematically runs the existing ones against every draft section.

Shared Enforcement

Read the constraint index: ${CLAUDE_PLUGIN_ROOT}/references/writing-common-constraints.md

Then load these phase-specific files:

Constraints:

• Read ${CLAUDE_PLUGIN_ROOT}/references/constraints/progressive-expansion-hierarchy.md

• Read ${CLAUDE_PLUGIN_ROOT}/references/constraints/constraint-loading-protocol.md

• Read ${CLAUDE_PLUGIN_ROOT}/references/constraints/flowchart-authority.md

• Read ${CLAUDE_PLUGIN_ROOT}/references/constraints/progress-gating.md

• Read ${CLAUDE_PLUGIN_ROOT}/references/constraints/drive-aligned-default.md

• Read ${CLAUDE_PLUGIN_ROOT}/references/constraints/context-monitoring.md

• Read ${CLAUDE_PLUGIN_ROOT}/references/constraints/claim-id-traceability.md

Conventions:

• Read ${CLAUDE_PLUGIN_ROOT}/references/conventions/gate-function-standard.md
• Read ${CLAUDE_PLUGIN_ROOT}/references/conventions/checkpoint-type-classification.md

Constraint Checks to Run

Load and run checks from three sources:

Source 1: Writing Constraints (atomic files loaded above)

Run these checks from the constraint files:

Source 2: Domain Skill

Read .planning/ACTIVE_WORKFLOW.md for the style field, then load the matching domain skill:

Run domain-specific checks against each draft section (citation format, style compliance, terminology).

Source 3: AI Anti-Patterns

Invoke Skill(skill="workflows:ai-anti-patterns") and check each draft section for AI writing indicators.

Flowchart — This IS the Spec

┌────────────────────────────┐
│  LOAD constraint checks    │
│  (constraints + domain +   │
│   ai-anti-patterns)        │
└────────────┬───────────────┘
             │
             ▼
┌────────────────────────────┐
│  READ .planning/PRECIS.md  │
│  Extract all CLAIM-XX IDs  │
└────────────┬───────────────┘
             │
             ▼
┌────────────────────────────┐
│  READ .planning/OUTLINE.md │
│  Map claims → sections     │
└────────────┬───────────────┘
             │
             ▼
┌────────────────────────────┐
│  For each claim:           │
│  READ drafts/ file         │◄──┐
│  RUN all constraint checks │   │
│  CLASSIFY: COVERED /       │   │
│    PARTIAL / MISSING       │   │
└────────────┬───────────────┘   │
             │                   │
             │ more claims       │
             └───────────────────┘
             │ all claims checked
             ▼
┌────────────────────────────┐
│  Run check-all.sh          │
│  (mechanical constraint    │
│   checks — hard block)     │
└────────────┬───────────────┘
             │
             ▼
┌────────────────────────────┐
│  WRITE .planning/          │
│  VALIDATION.md             │
└────────────┬───────────────┘
             │
        ┌────┴────┐
        │ status? │
        └────┬────┘
     ┌───────┴───────┐
     ▼               ▼
 validated      gaps_found
     │               │
     ▼               ▼
 → review      Present to user
                     │
              ┌──────┴──────┐
              ▼             ▼
           fix (→draft)  accept (→review)

Step 1: Load Constraint Checks

Load all three check sources before reading any drafts. This ensures every section is evaluated against the same criteria.

Step 2: Extract Claims from PRECIS

Read .planning/PRECIS.md and extract every claim:

• Main claims (thesis, sub-theses)
• Counterarguments to be addressed
• Audience-specific framing commitments
• Evidence commitments ("I will show X using Y")

Step 3: Map Claims to Sections

Read .planning/OUTLINE.md and map each claim to sections:

• Which section(s) address this claim?
• Is any claim orphaned (no section maps to it)?
• Is any section present that doesn't serve a claim?

Step 4: Read and Validate Each Draft

For each claim, read the corresponding draft file and run ALL constraint checks:

Step 5: Classify

Step 5b: Run Mechanical Constraint Checks (First Leg)

Run the constraint test suite as the first leg of two-legged verification:

bash ${CLAUDE_PLUGIN_ROOT}/scripts/check-all.sh

This runs all constraint check scripts (progressive-expansion, claim-id-traceability, flowchart-authority, no-pause-between-phases). Any failure is a hard block — fix before proceeding to Step 6.

The second leg (convention scoring via judgment) happens in Steps 4-5 above and in the writing-review phase.

Step 6: Flag Gaps to User

When gaps are found, present them with the specific check that failed:

• Fix: Return to writing-draft to address the gap
• Accept: Proceed to writing-review with known gaps

Only the user can decide whether a gap means the claim should be rewritten, dropped, or restructured.

Step 7: Write VALIDATION.md

Compile all results into .planning/VALIDATION.md using the template below.

VALIDATION.md Template

---
status: validated | gaps_found
date: [ISO 8601]
claims_total: N
covered: N
partial: N
missing: N
---
# Claim Validation

## Claims Map
| # | PRECIS Claim | Draft Section | Exists | Substantive | Evidence | Threading | Domain | AI Check | Classification |
|---|-------------|---------------|--------|-------------|----------|-----------|--------|----------|----------------|
| 1 | [from PRECIS] | [drafts/Section.md] | PASS | PASS | PASS | PASS | PASS | PASS | COVERED |
| 2 | [from PRECIS] | [drafts/Section.md] | PASS | PASS | WARN | PASS | PASS | WARN | PARTIAL |
| 3 | [from PRECIS] | — | FAIL | — | — | — | — | — | MISSING |

## Gap Details
[For any PARTIAL or MISSING claim, include:
- Which constraint check failed
- The specific finding
- Suggested remediation (for user decision)]

## Summary
- Claims: N total
- Covered: X
- Partial: Y
- Missing: Z

Status Rules

Gate

.planning/VALIDATION.md must exist before proceeding.

• If status is validated: proceed to writing-review.
• If status is gaps_found: present gaps to user before proceeding.
  • User decides: fix (return to writing-draft) or accept (proceed to writing-review with known gaps).

Gaps in claim coverage are not cosmetic — they mean the argument has holes. Only the user can decide whether a gap is acceptable or requires returning to the draft phase.

Rationalization Prevention

Drive-Aligned Framing

The protocol is not overhead you pay. It is the safety net you provide.

Phase Transition

After validation is complete, discover and read the writing-review skill: Read ${CLAUDE_PLUGIN_ROOT}/skills/writing-review/SKILL.md and follow its instructions.