Skip to content
Skills Library
AI & agents · Review & audit

doubt-driven

/doubt-driven

Use when a non-trivial decision sits under uncertainty and correctness matters more than speed. Not for patch review: use review.

Licence
Apache-2.0
Last repository change
10.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
3
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 10.11.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Use when a non-trivial decision sits under uncertainty and correctness matters more than speed. Not for patch review: use review.

Original author description

Use when a non-trivial decision sits under uncertainty and correctness matters more than speed. Not for patch review: use review.

How it works

  1. State the decision as a claim
  2. Isolate what the critic gets to see
  3. Get a hostile reading from a fresh mind
  4. Answer every finding honestly
  5. Knowing when to stop
  6. What you hand back
Original SKILL.md headings · 70 lines, 802 words
SKILL.md preview
---
name: doubt-driven
description: 'Use when a non-trivial decision sits under uncertainty and correctness matters more than speed. Not for patch review: use review.'
---

# Doubt-driven development

Some decisions are too important to trust to the person who just made them, including you. This skill sets up a hostile reading of your own work: you state the decision plainly, hand the bare evidence to a critic who has not seen your reasoning, and answer every objection before the decision ships. Everything here is read-only and runs in chat. Suggested fixes come back as recommendations you may apply yourself, never as edits this skill makes.

Use it for a non-trivial decision under uncertainty, for any claim the type system or compiler cannot check, and before committing non-trivial code. Do not use it for patch review; that belongs with review.

## State the decision as a claim

Name the decision compactly so it can actually be attacked:

```
CLAIM: "<statement>"
WHY THIS MATTERS: <consequence>
```

If you cannot state it that compactly, you do not have a decision yet; you have a vibe. Surface that and stop; nothing below can review a feeling.

## Isolate what the critic gets to see

Pull out the smallest unit that fits in one read: the artifact (a diff, function, proposal, or assertion plus its supporting evidence) and the contract (the constraint the artifact must satisfy). Strip out your reasoning before handing it over. A reviewer who sees your conclusions will validate them instead of breaking them. A 500-line PR is not one unit; decompose it first.

## Get a hostile reading from a fresh mind

Spawn a fresh-context subagent with isolated context and give it this adversarial prompt verbatim, so it overrides any default balanced-response shape:

```
Adversarial review. Find what is wrong with this artifact.
Assume the author is overconfident. Look for:
- Unstated assumptions
- Edge cases not handled
- Hidden coupling or shared state
- Ways the contract could be violated
- Existing conventions this might break
- Failure modes under unexpected input

Do NOT validate. Do NOT summarize. Find issues, or state
explicitly that none could be found after thorough examination.

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

Pass ARTIFACT plus CONTRACT only. Never pass the CLAIM: handing the critic your conclusion biases it toward agreement. If a reviewer's default shape cannot be overridden to issues-only, fall back to a generic subagent carrying the same prompt.

This step needs the main session, where spawning a fresh-context reviewer works. From inside a subagent, spawning another subagent is blocked, so do not run this skill nested. Surface that to the user and let the main session handle it. Only as a last resort, fall back to questioning yourself: rewrite ARTIFACT plus CONTRACT as a fresh self-prompt behind a hard mental separator from your prior reasoning and walk the same steps. That is not fresh-context review, so flag the result as degraded.

## Answer every finding honestly

Re-read the artifact against each finding before classifying it. Rubber-stamping the critic fails just as surely as ignoring it. Take each finding in this order: first match wins.

1. **Contract misread.** The CONTRACT was unclear or incomplete. Fix the contract and re-classify next cycle.
2. **Valid and actionable.** A real issue. Change the artifact and loop again.
3. **Valid trade-off.** Real, but fixing costs more than accepting. Document the trade-off.
4. **Noise.** Correct under context the reviewer lacked. Note it, and consider adding that context to the contract.

For the highest-severity valid finding, name the cheapest check that would overturn it (a file read, a single command, a minimal reproduction) and run that check before looping again. When no check is cheaper than the fix, record null with the reason instead of inventing one.

Watch for doubt theater: across 2 or more cycles where the critic surfaced substantive findings, zero findings classified as actionable means the critic is validating, not doubting. Stop and escalate to the user.

## Knowing when to stop

Stop when the next iteration returns only trivial or already-considered findings, when 3 cycles are done, or when the user explicitly says to ship. Three cycles is the bound, not a suggestion: do not grind a fourth alone; escalate to the user instead. If 3 cycles still surface substantive issues, that is information about the artifact: it may not be ready, so say so. If 3 cycles is obviously insufficient because the artifact is large, the artifact is too big. Go back, decompose it, and review the pieces. Never lift the bound to fit the artifact.

A stopped cycle with every finding classified is a valid partial result. Unclassified or rubber-stamped findings are not.

## What you hand back

A report listing each CLAIM, the fresh-context findings, each finding's classification (contract misread / valid + actionable / valid trade-off / noise), and the stop condition met. Actionable findings carry a recommended artifact change, stated as a recommendation, not an applied edit.
Files in this package (3)
  • SKILL.md 5 KB
  • agents/openai.yaml 1 KB
  • references/orchestration-patterns.md 17 KB

Versions

RepositoryScoreLicence
This page · gosuda/dalcom-skills100Apache-2.0
OutlineDriven/outline-driven-development100Apache-2.0

Database snapshot: 13.11.2026 · package version 21175abc63ed (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100doubt-driven-development
    Subjects every non-trivial decision to a fresh-context adversarial review before it stands. Use when you want every assumption cross-examined before proceeding, when stress-testing a plan for hidden failure modes, when correctness matters more than speed, when working in…
  • 100doubt-driven-development
    Subjects every non-trivial decision to a fresh-context adversarial review before it stands. Use when correctness matters more than speed, when working in unfamiliar code, when stakes are high (production, security-sensitive logic, irreversible operations), or any time a…
  • 100doubt-driven-development
    Subjects every non-trivial decision to a fresh-context adversarial review before it stands. Use when correctness matters more than speed, when working in unfamiliar code, when stakes are high (production, security-sensitive logic, irreversible operations), or any time a…
  • 100doubt-driven-development
    Subject every non-trivial decision to fresh-context adversarial review before it stands. Use when correctness beats speed or stakes are high. Do NOT use as primary loop — layer on spec/test/source-driven.
  • 100doubt-driven-development
    Subject every non-trivial decision to fresh-context adversarial review before it stands. Use when correctness beats speed or stakes are high. Do NOT use as primary loop — layer on spec/test/source-driven.
  • 100doubt-driven-development
    Subjects every non-trivial decision to a fresh-context adversarial review before it stands. Use when correctness matters more than speed, when working in unfamiliar code, when stakes are high (production, security-sensitive logic, irreversible operations), or any time a…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.