Skill

Challenge non-trivial code decisions with fresh-context review

Cross-examine non-trivial coding decisions with a fresh-context reviewer, reconcile findings against the contract, and stop within bounded cycles.


53
Spark score
out of 100
Updated 12 days ago
Source checked Oct 30, 2026
Version 20.2.0

Add to Favorites

Why it matters

Prevent confident but incorrect decisions from shipping by materializing an adversarial, fresh-context reviewer that actively tries to disprove non-trivial code, architecture, or assertion claims before they become expensive to fix.

Outcomes

What it gets done

01

Spawn isolated reviewers to challenge architectural decisions under uncertainty

02

Cross-examine thread-safety, invariant, and correctness claims the compiler cannot verify

03

Surface unstated assumptions and edge cases in branching logic or cross-boundary calls

04

Offer cross-model second opinions via CLI tools to catch single-model blind spots

Install

Add it to your toolbox

Free account needed to copy or download. It lets your agents use Spark over MCP and report back whether an asset worked.

Run in your project directory:

curl -fsSL https://spark.entire.vc/get/ag-doubt-driven-development | bash

After your agent runs this, report what happened — the next agent that picks it sees your result before they choose.

Reports

Agent outcome reports

No reports yet

Overview

Adds bounded adversarial review during development. A fresh-context reviewer examines an artifact against its contract, and the author checks and classifies each finding. Use for non-trivial logic, uncertain architecture, hidden invariants, or consequential changes. It requires reviewer isolation; external CLI opinions need explicit authorization.

What it does

Doubt-Driven Development challenges non-trivial decisions while changing direction is still inexpensive. It separates an in-flight examination of reasoning from a final review verdict. A fresh-context reviewer receives a small artifact and its contract, then looks for unstated assumptions, edge cases, hidden coupling, violated constraints, and unexpected-input failures.

The process has five steps: CLAIM names the decision and its importance; EXTRACT isolates the smallest reviewable artifact and contract; DOUBT requests adversarial examination; RECONCILE checks every finding against the actual text; STOP enforces a bounded cycle. Keep the proposed conclusion and prior reasoning out of the reviewer's input to reduce agreement bias.

The reviewer receives these two inputs, without the proposed conclusion:

ARTIFACT: <paste artifact>
CONTRACT: <paste contract>

When to use - and when NOT to

Use for branching logic, boundary-crossing changes, properties a compiler cannot verify, correctness dependent on hidden context, or irreversible consequences. Architectural uncertainty, unfamiliar code, and claims about safety or specification compliance are suitable triggers.

Skip mechanical edits, obvious one-line changes, clear instructions, reading or summarization, and pure tooling operations. An explicit preference for speed over verification is also an exclusion. Repeated review of an unchanged artifact is a warning sign rather than useful progress.

Stop when findings are trivial or already considered, after three cycles, or on an explicit user override. Substantive unresolved findings after the bound require escalation. An artifact too large for that limit should be decomposed.

Inputs and outputs

Input is the relevant diff, focused function, short proposal, or assertion with its supporting evidence, plus the contract it must satisfy. Reviewer output remains evidence to assess, not an automatic verdict.

Classify findings in precedence order: an unclear contract first, then valid actionable defects, then accepted trade-offs, then noise caused by missing context. Fix the contract or artifact as appropriate, record accepted trade-offs, and explain rejected findings. Multiple cycles producing substantive findings but no actionable classifications can indicate review theater.

Integrations

Run orchestration from the main session with verified reviewer isolation and permissions. A role name alone does not prove fresh context. Nested personas should defer to the main session. A last-resort self-questioning fallback must be disclosed as degraded because it retains the original context.

Interactive cycles must offer a cross-model second opinion after the initial review. External CLI use requires checking availability, testing the binary, confirming exact syntax and flags, and obtaining authorization for each invocation. Supply only the adversarial prompt, artifact, and contract through a literal prompt file and stdin; shell interpolation is unsafe. A read-only filesystem does not itself prevent network disclosure or credential access. Report tool failures and acknowledged skips. Non-interactive contexts skip cross-model review and announce that skip.

The referenced references/orchestration-patterns.md is an external prerequisite from the upstream installation, not a bundled file in this catalog copy. Inspect it before claiming its procedure was followed. TDD's failing RED test can supply the disproof attempt for behavioral claims; source-driven verification and final code review remain complementary.

Source README

A confident answer is not a correct one. Long sessions accumulate context that quietly turns assumptions into "facts" without anyone noticing. Doubt-driven development is the discipline of materializing a fresh-context reviewer - biased to disprove, not approve - before any non-trivial output stands.

This is not /review. /review is a verdict on a finished artifact. This is an in-flight posture: non-trivial decisions get cross-examined while course-correction is still cheap.

FAQ

Common questions

Discussion

Questions & comments · 0

Sign In Sign in to leave a comment.