skill
gold-team-development
Skill Devs within methodology WoT - wrangling of thought
Set up
Skills are installed by placing their folder where your agent loads skills.
The download comes from github.com/thiagobluhm/gold-team-development itself, not from our server, so what you get is exactly what its author published.
Install instructions come from the README
README
synced Oct 26, 2026gold-team-development
A Claude Code skill that runs hard development problems through a team of real subagents instead of one model thinking alone — using the WoT (Wrangling of Thought) methodology: independent reasoning, adversarial cross-critique, and arbitration toward the hypothesis that survives attack rather than the one that sounds most confident.
WoT is not borrowed terminology. It is a research framework by Thiago Bluhm (Universidade de Fortaleza), and this repository is its applied port to software engineering.
The research behind it
WoT: A Reflexive Multi-Agent Review Framework with Cross-Critique and Layered Reasoning Toward Explainable LLM Architectures with Multi-Agent Validation Thiago Bluhm — Universidade de Fortaleza, Fortaleza, Brazil
The paper proposes epistemic triangulation — Reason → Critique → Arbitrate — as a first-class architectural principle rather than a prompting trick. Instead of one model reflecting on itself (Reflexion, Self-Refine) or many models voting on shallow outputs (Majority Voting, Debate), WoT has agents reason independently, critique each other's reasoning, and submit to an arbiter that weighs semantic density against critique quality. Truth is treated as a negotiated outcome, not a single path to be approximated.
Evaluated on legal document classification (161 annotated texts, 9 classes, GPT-4-turbo), the study's central finding is a deliberate trade: WoT gave up raw accuracy (0.46 vs CoT's 0.56) and bought the highest precision of all methods tested (0.74), the best readability, and a hallucination rate under 6%. In high-stakes domains, that trade is the point — confident misclassification costs more than withheld judgment.
The ablation is what justifies keeping every phase of this skill:
| Component removed | Effect measured in the study |
|---|---|
| Arbitration | Accuracy drops to 0.459 — decisions skew toward the most verbose chain |
| Critique | Accuracy drops to 0.435 — flawed logic survives unchallenged |
| Semantic density scoring | Hallucination rate jumps from 5.4% to over 12% |
"Decisions skew toward the most verbose chain" is precisely the failure mode a single agent exhibits on a hard bug: the most elaborate story wins, not the best-evidenced one.
How this skill maps to the paper
| WoT stage (paper) | This skill |
|---|---|
| Independent Reasoning — agents A and B process the same document blind | Phase 1 — three investigators, blind to each other, one assigned angle each |
| Cross-Critique — each agent critiques the other's chain | Phase 2 — each investigator attacks the two hypotheses it did not write, and must verify a cited file:line with its own tools |
| Arbitration — a third agent weighs semantic density against critique quality | Phase 3 convergence + Phase 4 QA, which explicitly rates whether the critique was substantive or superficial |
| Final Synthesis — the most epistemically robust chain becomes the decision | Phase 6 Judge, over the actual diff |
Two deliberate departures from the paper:
- Arbitration here is qualitative. The paper computes
J = argmax [α·S(x) + β·C(x)]with calibrated weights. This skill has no calibrated scorer in the loop, so it forbids invented confidence numbers outright — a fabricated "0.74 confidence" would be false precision dressed as the paper's formalism. - CAG is not implemented. The paper's Cache-Augmented Generation reuses validated reasoning chains across runs as an evolving epistemic memory. This port has no such memory: every run starts cold. It is the most valuable thing still missing here.
Why
A single agent investigating a hard bug tends to fall in love with its first plausible explanation. Nothing in its loop is designed to kill that explanation. This protocol adds what's missing: three investigators who don't see each other, a round where they attack each other's hypotheses with evidence, two blind QA reviewers who judge the quality of the reasoning rather than redo it, a judge over the final diff, and a senior dev who applies the fix under an anti-bloat rule.
When to use it
Only for high-complexity work:
- Bugs whose root cause is not obvious on first read
- Architectural decisions with real trade-offs
- Changes that touch several parts of a system
Not for simple or localized fixes — the protocol runs 9+ subagent invocations, and a single agent solves those faster and with less noise.
Install
Copy the two directories into your Claude Code configuration:
# global (available in every project)
cp -r skills/gold-team-development ~/.claude/skills/
cp agents/gtd-*.md ~/.claude/agents/
# or per project
cp -r skills/gold-team-development .claude/skills/
cp agents/gtd-*.md .claude/agents/
On Windows (PowerShell):
Copy-Item skills\gold-team-development $env:USERPROFILE\.claude\skills\ -Recurse -Force
Copy-Item agents\gtd-*.md $env:USERPROFILE\.claude\agents\ -Force
Skills and agents are picked up live — no restart needed, unless the .claude/skills/ directory did not exist when the session started.
Usage
/gold-team-development
…or just ask for it in your own words ("run GTD on this bug", "use Wrangling of Thought here").
The skill first asks which model to use for each role and at what effort level — every time it is triggered, by design, so nine subagents never run on the wrong model without you noticing.
The team
| Agent | Runs | Job | Can edit files |
|---|---|---|---|
gtd-investigator | 6x | Mode 1: one hypothesis from one assigned angle, blind to the others. Mode 2: attacks two rival hypotheses it did not write. | No |
gtd-qa | 2x | Judges the reasoning, not the code: does the cause explain the symptom, does the fix attack cause or symptom, was the critique substantive or superficial. Blind to each other. | No |
gtd-judge | 1x+ | Final gate over the diff: adherence, architecture, cohesion, simplicity — deliberating with both QA verdicts as input. | No |
gtd-senior-dev | 1x | Applies the approved fix, after an explicit 7-question self-ask pass, at pinned high effort. | Yes |
Only the senior dev can write. Everyone else is read-only by construction, so no gate can quietly "fix" what it was supposed to be judging.
The flow
| Phase | What happens |
|---|---|
| 0 — Configuration | Asks model per role + effort level. Every run, no cached defaults. |
| 1 — Independent Reasoning | 3 investigators in parallel, one angle each (data · logic · integration), blind to each other. |
| 2 — Cross-Critique (WoT) | 3 more in parallel, each attacking the two hypotheses it didn't write. Every critique must verify at least one cited file:line with its own tools. |
| 3 — Convergence | The orchestrator picks the hypothesis that survived with the fewest fatal objections — or reports a genuine no-consensus instead of forcing one. |
| 4 — QA | 2 reviewers in parallel, blind to each other. APPROVE, or SEND BACK to phase 1 (cause is wrong) or phase 2 (critique was too soft). |
| 5 — Implementation | The orchestrator implements under the Simplicity Rule. |
| 6 — Judge | APPROVE · REQUEST TARGETED FIX · REJECT. |
| 7 — Handoff Package | A self-contained briefing is written and shown to you for confirmation before anyone else is dispatched. |
| 8 — Senior Dev | Applies exactly what the package scopes, then reports the diff and the test result. Substantive changes go back through the Judge once. |
Design rules that make it work
- Evidence means
file:line, command output, or a measurement — never recollection. Anything unverified must be labeledUNVERIFIED. - No invented confidence scores. The judgment is qualitative; a number like "0.74 confidence" is false precision.
- Blindness is the point. Investigators and QA reviewers never see their peers' work before producing their own.
- The scope is a contract. The senior dev implements exactly what the handoff package lists — anything else it noticed is reported, not fixed.
- Anti-bloat, everywhere. No abstractions for single-use cases, no speculative code, no collateral cleanup. If it runs past 200 lines but fits in 50, it gets rewritten.
- A red test is an attestation. Never weakened to make a run go green.
Requirements
Claude Code with subagent support. The skill refuses to run if any of the four agents is missing — it will name the missing one rather than silently simulate the role, because a simulated role defeats the entire protocol.
Credits
The WoT (Wrangling of Thought) framework — independent reasoning, cross-critique, arbitration, and the epistemic triangulation that binds them — is research by Thiago Bluhm, Universidade de Fortaleza. This repository is its applied port to software engineering: the same three-stage deliberation, aimed at root-cause analysis and code changes instead of legal document classification.
If you build on this, cite the framework, not just the skill.
License
MIT — see LICENSE.