### Workflow

Copy this checklist and check off items as you complete them:

```
CoVe Isolated Progress:
- [ ] Step 1: Generate Initial Answer
- [ ] Step 2: Create Verification Questions
- [ ] Step 3: Isolated Verification (Sub-Agents)
- [ ] Step 4: Reconciliation & Final Answer
```

> **Note:** Step 3 uses isolated sub-agents for true factored verification. Each verification question is answered by a separate agent with zero context about the initial answer.

---

## Step 1: Initial Response

Generate the initial answer to the user's question. This establishes a baseline that will be verified.

**Requirements:**
- Mark the response clearly as "Initial Answer"
- Provide a complete response (not abbreviated)
- Note any areas of uncertainty

---

## Step 2: Generate Verification Questions

Create 3-5 targeted questions designed to expose potential errors in the initial answer.

### Question Categories

| Category | Purpose | Example |
|----------|---------|---------|
| Factual | Verify specific claims | "What is the exact release date of X?" |
| Logical | Check reasoning consistency | "Does conclusion Y follow from premise X?" |
| Edge cases | Find exceptions | "What happens when input is empty/null?" |
| Assumptions | Challenge implicit beliefs | "Is it true that all X have property Y?" |
| Technical | Verify specifications | "What does the official documentation say about X?" |

### Guidelines for Effective Verification Questions

- Target the most critical or uncertain claims in the initial answer
- Phrase questions so they can be answered independently
- Avoid leading questions that assume the initial answer is correct
- Include at least one question that challenges a core assumption

---

## Step 3: Isolated Verification with Sub-Agents

**CRITICAL: This step uses true factored verification by spawning isolated sub-agents.**

Each verification question is answered by a separate sub-agent that has ZERO context about the initial answer. This eliminates the risk of hallucination repetition that exists in standard mode.

> **Capy and isolation:** Do NOT pre-load capy search results into sub-agent prompts — curating and injecting results leaks the main agent's framing. Sub-agents may independently query capy as part of their own tool-first research, just like WebSearch — they form their own queries without knowledge of the initial answer.

### Flag Parsing

The following flags can be used with `/kk:chain-of-verification:isolated`:

| Flag | Effect | Default |
|------|--------|---------|
| `--explore` | Use `Explore` agent type | - |
| `--haiku` | Use haiku model for sub-agents | - |
| `--agent=<name>` | Use custom agent type | `general-purpose` |

**Flag parsing rules:**
1. Flags must appear before the question in `$ARGUMENTS`
2. `--explore` is shorthand for `--agent=Explore`
3. `--haiku` sets the `model` parameter to `haiku` on the Task tool
4. `--agent=<name>` uses the specified agent type (default: `general-purpose`)
5. Flags can be combined: `--haiku --explore`

### Sub-Agent Prompt Template

Use this template for each sub-agent. Replace `{verification_question}` with the actual question:

```
You are answering a factual question. Research thoroughly using available tools
before answering. Cite your sources.

Question: {verification_question}

Requirements:
1. Use WebSearch, context7, Read, or other tools to verify your answer
2. If you cannot find authoritative sources, state that clearly
3. Provide a concise, factual answer with source citations
4. Do NOT speculate - only report what you can verify
```

### Task Tool Usage

For EACH verification question, create a Task tool call with:

| Parameter | Value |
|-----------|-------|
| `subagent_type` | From `--agent` flag or default `general-purpose` |
| `model` | `haiku` if `--haiku` flag present, otherwise omit |
| `prompt` | Sub-agent prompt template with `{verification_question}` substituted |
| `description` | `CoVe Q{N}: {first 5 words of question}...` |

**CRITICAL: All Task calls must be in a SINGLE message for parallel execution.**

### Example: 3 Verification Questions

If you have these verification questions:
1. What is the exact time complexity of Python's sorted() function?
2. Does Python's sorted() use Timsort or another algorithm?
3. What is the space complexity of Python's sorted()?

You must spawn all three sub-agents in ONE message block. Each Task call should have:
- `subagent_type`: `general-purpose` (or from flags)
- `description`: `CoVe Q1: What is the exact...` (truncated)
- `prompt`: The sub-agent prompt template with the question substituted

Example Task tool parameters for Q1:
```json
{
  "subagent_type": "general-purpose",
  "description": "CoVe Q1: What is the exact...",
  "prompt": "You are answering a factual question. Research thoroughly using available tools before answering. Cite your sources.\n\nQuestion: What is the exact time complexity of Python's sorted() function?\n\nRequirements:\n1. Use WebSearch, context7, Read, or other tools to verify your answer\n2. If you cannot find authoritative sources, state that clearly\n3. Provide a concise, factual answer with source citations\n4. Do NOT speculate - only report what you can verify"
}
```

With `--haiku` flag, add `"model": "haiku"` to each Task call.
With `--explore` flag, use `"subagent_type": "Explore"` instead.

### Response Collection

After all sub-agents complete:

1. **Collect responses** from all sub-agents
2. **Record metadata** for each:
   - Agent type used (general-purpose, Explore, etc.)
   - Completion status (Completed, Failed, Timed out)
   - Source citations provided
3. **Note any failures** - these will be marked as "Inconclusive" in reconciliation

---

## Step 4: Reconciliation & Final Answer (Factor+Revise)

This step implements the "Factor+Revise" pattern—systematically comparing each sub-agent's verification answer against the corresponding claim in the initial answer.

### Structured Reconciliation Process

1. **Claim-by-claim comparison** - For each verification Q&A pair:
   - Identify the specific claim in the initial answer it verifies
   - Compare the sub-agent's verification answer to that claim
   - Mark as: ✓ Confirmed, ✗ Contradicted, or ? Inconclusive

2. **Resolution rules**:
   - **Contradicted claims**: Sub-agent verification answer takes precedence (used external sources in isolation)
   - **Inconclusive claims**: Mark as uncertain in final answer, or remove if not essential
   - **Confirmed claims**: Keep in final answer with increased confidence

3. **Produce revised answer**:
   - Incorporate all corrections from contradicted claims
   - Explicitly note uncertainties for inconclusive claims
   - Preserve confirmed claims

4. **Document changes** - List what was corrected and why, with agent attribution
5. **Capy search:** For contradicted or inconclusive claims, search `kk:` broadly for project-specific facts that may help adjudicate

### If No Errors Found

- Confirm the original answer is accurate
- Note that independent verification supports the initial response
- This adds confidence—the answer has been externally validated by isolated agents

---

## Output Format Template

Use this format for CoVe Isolated responses:

```markdown
## Initial Answer
[Complete initial response to the question]

## Verification (Isolated Mode)

### Q1: [First verification question]
**Agent:** general-purpose | **Status:** ✓ Completed
**A1:** [Sub-agent's independent answer]
**Source:** [Citation from sub-agent]

### Q2: [Second verification question]
**Agent:** general-purpose | **Status:** ✓ Completed
**A2:** [Sub-agent's independent answer]
**Source:** [Citation from sub-agent]

### Q3: [Third verification question]
**Agent:** Explore | **Status:** ✓ Completed
**A3:** [Sub-agent's independent answer]
**Source:** [Citation from sub-agent]

[Additional questions as needed...]

## Reconciliation

| Claim | Verification | Status | Action |
|-------|--------------|--------|--------|
| [Claim from initial answer] | Q1 | ✓ Confirmed | Keep |
| [Another claim] | Q2 | ✗ Contradicted | Correct to: [new value] |
| [Third claim] | Q3 | ? Inconclusive | Mark uncertain |

## Final Verified Answer
[Revised response incorporating all corrections from reconciliation]

**Verification notes:**
- Isolation method: Sub-agent (true factored verification)
- Agents used: [count]x [types] (e.g., "2x general-purpose, 1x Explore")
- Corrections: [List specific changes made]
- Confirmations: [List verified claims]
```

---

## Error Handling

### Sub-Agent Timeout

If a sub-agent times out, mark that verification as "Inconclusive":

```markdown
### Q2: [Question]
**Agent:** general-purpose | **Status:** ⏱ Timed out
**A2:** Inconclusive - sub-agent timeout
**Source:** N/A
```

In reconciliation, treat timed-out verifications as `? Inconclusive`.

### Sub-Agent Failure

If a single sub-agent fails (but others succeed):

1. Mark that verification as failed in the output
2. **Fall back to standard mode** for that question only
3. Note in the output that standard mode was used for fallback

```markdown
### Q3: [Question]
**Agent:** general-purpose | **Status:** ✗ Failed (fallback to standard)
**A3:** [Answer using standard mode - prompt-based isolation]
**Source:** [Citation] (Note: Standard mode fallback)
```

### All Sub-Agents Fail

If ALL sub-agents fail, abort isolated mode entirely:

1. Do NOT attempt standard mode fallback for all questions
2. Display this message to the user:

```
Isolated mode unavailable due to sub-agent failures.
Please use `/kk:chain-of-verification` for standard mode verification instead.
```

3. Suggest the user retry with `/kk:chain-of-verification` (standard mode)

### Workflow

Copy this checklist and check off items as you complete them:

```
CoVe Progress:
- [ ] Step 1: Generate Initial Answer
- [ ] Step 2: Create Verification Questions
- [ ] Step 3: Independent Verification
- [ ] Step 4: Reconciliation & Final Answer
```

---

## Step 1: Initial Response

Generate the initial answer to the user's question. This establishes a baseline that will be verified.

**Requirements:**

- Mark the response clearly as "Initial Answer"
- Provide a complete response (not abbreviated)
- Note any areas of uncertainty

---

## Step 2: Generate Verification Questions

Create 3-5 targeted questions designed to expose potential errors in the initial answer.

### Question Categories

| Category    | Purpose                     | Example                                             |
| ----------- | --------------------------- | --------------------------------------------------- |
| Factual     | Verify specific claims      | "What is the exact release date of X?"              |
| Logical     | Check reasoning consistency | "Does conclusion Y follow from premise X?"          |
| Edge cases  | Find exceptions             | "What happens when input is empty/null?"            |
| Assumptions | Challenge implicit beliefs  | "Is it true that all X have property Y?"            |
| Technical   | Verify specifications       | "What does the official documentation say about X?" |

### Guidelines for Effective Verification Questions

- Target the most critical or uncertain claims in the initial answer
- Phrase questions so they can be answered independently
- Avoid leading questions that assume the initial answer is correct
- Include at least one question that challenges a core assumption

---

## Step 3: Independent Verification (Factored)

**CRITICAL: Answer each verification question in complete isolation using the FACTORED approach.**

This step implements "factored verification" from the Meta AI research—the most effective method for catching errors. The key insight: if you can see your initial answer while verifying, you may unconsciously repeat the same hallucination.

### Factored Verification Protocol

For EACH verification question:

1. **Mental reset** - Before answering, mentally "forget" the initial answer. Treat this as a brand new question from a user you've never interacted with.

2. **Tool-first verification** - Prioritize external sources over your own knowledge. **Capy search:** Search `kk:` broadly for any indexed knowledge relevant to the verification questions.
   - Use `WebSearch` for facts, dates, statistics
   - Use `context7` for library/API documentation
   - Use `Read`/`Grep` for code verification
   - Only rely on internal knowledge if tools are unavailable or inappropriate

3. **Answer in isolation** - Do NOT:
   - Reference "my initial answer" or "I said earlier"
   - Look back at Step 1 while answering
   - Let other verification answers influence this one

4. **Cite your source** - Note where the answer came from (tool result, documentation, etc.)

### Why Factored Verification Works

Research shows that when the model can see its draft while answering verification questions, it copies the same hallucination. The factored approach eliminates this by:

- Treating each question as a completely independent query
- Prioritizing external tools over self-reference
- Preventing cross-contamination between verification answers

### Tool Usage Priority

| Priority | Tool               | Use Case                                         |
| -------- | ------------------ | ------------------------------------------------ |
| 1st      | WebSearch          | Current facts, dates, statistics, recent changes |
| 2nd      | context7           | Library docs, API references, technical specs    |
| 3rd      | Read/Grep          | Code verification, codebase patterns             |
| Last     | Internal knowledge | Only when tools unavailable or not applicable    |

---

## Step 4: Reconciliation & Final Answer (Factor+Revise)

This step implements the "Factor+Revise" pattern—systematically comparing each verification answer against the corresponding claim in the initial answer.

### Structured Reconciliation Process

1. **Claim-by-claim comparison** - For each verification Q&A pair:
   - Identify the specific claim in the initial answer it verifies
   - Compare the verification answer to that claim
   - Mark as: ✓ Confirmed, ✗ Contradicted, or ? Inconclusive

2. **Resolution rules**:
   - **Contradicted claims**: Verification answer takes precedence (it used external sources)
   - **Inconclusive claims**: Mark as uncertain in final answer, or remove if not essential
   - **Confirmed claims**: Keep in final answer with increased confidence

3. **Produce revised answer**:
   - Incorporate all corrections from contradicted claims
   - Explicitly note uncertainties for inconclusive claims
   - Preserve confirmed claims

4. **Document changes** - List what was corrected and why
5. **Capy search:** For contradicted or inconclusive claims, search `kk:` broadly for project-specific facts that may help adjudicate

### If No Errors Found

- Confirm the original answer is accurate
- Note that independent verification supports the initial response
- This adds confidence—the answer has been externally validated

---

## Output Format Template

Use this format for CoVe responses:

```markdown
## Initial Answer

[Complete initial response to the question]

## Verification

### Q1: [First verification question]

**A1:** [Independent answer - cite source: WebSearch/context7/docs/internal]

### Q2: [Second verification question]

**A2:** [Independent answer - cite source]

### Q3: [Third verification question]

**A3:** [Independent answer - cite source]

[Additional questions as needed...]

## Reconciliation

| Claim                       | Verification | Status         | Action                  |
| --------------------------- | ------------ | -------------- | ----------------------- |
| [Claim from initial answer] | Q1           | ✓ Confirmed    | Keep                    |
| [Another claim]             | Q2           | ✗ Contradicted | Correct to: [new value] |
| [Third claim]               | Q3           | ? Inconclusive | Mark uncertain          |

## Final Verified Answer

[Revised response incorporating all corrections from reconciliation]

**Verification notes:**

- [List corrections: "Changed X to Y based on Q2 verification"]
- [List confirmations: "Verified X is correct via WebSearch"]
- [List uncertainties: "Could not verify Y - marked as uncertain"]
```

---
name: chain-of-verification
description: |
  Apply Chain-of-Verification (CoVe) prompting to improve response accuracy through self-verification.
  Use when complex questions require fact-checking, technical accuracy, or multi-step reasoning.
---

# Chain-of-Verification (CoVe)

CoVe is a verification technique that improves response accuracy by making the model fact-check its own answers. Instead of accepting an initial response at face value, CoVe instructs the model to generate verification questions, answer them independently, and revise the original answer based on findings.

## Conventions

- **Read capy knowledge base conventions** at [shared-capy-knowledge-protocol.md](shared-capy-knowledge-protocol.md).

**Capy restriction:** CoVe is a read-only verification tool. Do NOT call `capy_index` or `capy_fetch_and_index` during this workflow. Use `capy_search` only. If corrections reveal knowledge worth persisting, the calling agent handles indexing after CoVe completes.

## When to Use This Skill

CoVe adds the most value in these scenarios:

**Precision-required questions:**

- Questions containing precision language ("exactly", "precisely", "specific")
- Complex factual questions (dates, statistics, specifications)

**Complex reasoning:**

- Multi-step reasoning chains (3+ logical dependencies)
- Technical claims about APIs, libraries, or version-specific behavior

**Fact-checking scenarios:**

- Historical facts, statistics, or quantitative data
- Technical specifications and API behavior

**High-stakes accuracy:**

- Security-critical code paths or analysis
- Code generation requiring accuracy verification
- Any response where correctness is critical

**Self-correction triggers:**

- When initial response contains hedging language ("I think", "probably", "might be")

> **Note:** These heuristics can be copied to your project's CLAUDE.md if you want Claude to auto-invoke CoVe for matching scenarios. By default, CoVe requires manual invocation to give you control over when to invest additional tokens/time for verification.

## Verification Modes

CoVe offers two verification modes to balance accuracy vs. cost:

### Standard Mode (`/kk:chain-of-verification`)

Uses prompt-based isolation within a single conversation turn.

- **Token cost:** ~3-5x base tokens
- **Isolation:** Best-effort (mental reset instructions)
- **Speed:** Faster, single context
- **Best for:** Quick fact-checking, cost-sensitive scenarios

See [chain-of-verification-process.md](./chain-of-verification-process.md) for the standard workflow.

### Isolated Mode (`/kk:chain-of-verification:isolated`)

Uses Claude Code's Task tool to spawn isolated sub-agents for true factored verification.

- **Token cost:** ~8-15x base tokens
- **Isolation:** True (sub-agents have zero context about initial answer)
- **Speed:** Parallel execution minimizes latency
- **Best for:** High-stakes accuracy, codebase verification

**Sub-agent customization flags:**
| Flag | Effect |
|------|--------|
| `--explore` | Use Explore agent for codebase verification |
| `--haiku` | Use haiku model for faster/cheaper verification |
| `--agent=<name>` | Use custom agent type |

See [chain-of-verification-isolated.md](./chain-of-verification-isolated.md) for the isolated workflow.

### Mode Selection Guide

| Use Case                    | Recommended Mode                                                            |
| --------------------------- | --------------------------------------------------------------------------- |
| Quick fact-checking         | `/kk:chain-of-verification`                                                 |
| High-stakes accuracy        | `/kk:chain-of-verification:isolated`                                        |
| Codebase verification       | `/kk:chain-of-verification:isolated --explore`                              |
| Cost-sensitive verification | `/kk:chain-of-verification` or `/kk:chain-of-verification:isolated --haiku` |

## Workflow

**Mandatory order — questions before verification.** The flow below is strictly sequential. Do not answer verification questions, consult external sources, or revise the original response until you have generated the full initial response and formulated all verification questions. Jumping to verification before questions are fully formed collapses the independence that makes CoVe effective.

1. **Generate initial response.** Produce a baseline answer to the user's question. This is the subject matter — it exists in context but is not yet verified.
2. **Formulate verification questions.** Create 3–5 targeted questions designed to expose errors in the initial response. The questions must be formulated without consulting external sources — they probe the response's own claims.
3. **Independent verification.** Answer each question independently, without referencing the initial response. Use `capy_search` if needed. In isolated mode, sub-agents handle this step.
4. **Reconciliation.** Compare verification answers against the initial response. Revise where discrepancies are found.

See [chain-of-verification-process.md](./chain-of-verification-process.md) for the standard workflow, or [chain-of-verification-isolated.md](./chain-of-verification-isolated.md) for the isolated sub-agent workflow.

## Invocation

Use the `/kk:chain-of-verification` skill followed by your question:

```
/kk:chain-of-verification What is the time complexity of Python's sorted() function?
```

Or invoke `/kk:chain-of-verification` after receiving a response to verify it.

For isolated verification with sub-agents:

```
/kk:chain-of-verification:isolated What is the time complexity of Python's sorted() function?
```

With flags:

```
/kk:chain-of-verification:isolated --explore How does the auth system work?
/kk:chain-of-verification:isolated --haiku What year was TCP standardized?
```

## Natural Language Invocation

Claude should recognize these phrases as requests to invoke the CoVe skill:

- "verify this using chain of verification"
- "use CoVe to answer"
- "fact-check your response"
- "double-check this with verification"
- "use self-verification for this"
- "apply chain of verification"
- "verify this answer"

For isolated mode:

- "use isolated verification"
- "verify with sub-agents"
- "use factored verification with isolation"

> **Important:** This is guidance for manual recognition only. Auto-trigger is NOT implemented by default per design goals. Users who want automatic CoVe invocation for certain scenarios can add the heuristics from "When to Use This Skill" to their project's CLAUDE.md.