// Cross-context adversarial review for deliverables before shipping. Use when producing blog posts, technical recommendations, analysis briefs, code, or any artifact where accuracy matters more than speed. Triggers on "challenge this", "review before shipping", "adversarial pass", "stress test this".
Disciplined, validation-gated revision of an EXISTING skill so each edit is a measured improvement rather than a guess. Use when editing, revising, or tuning a skill that already exists and there is evidence it underperforms (observed failures, drift, complaints) — invoke by name, or have versioning-skills / creating-skill defer to it before applying edits. Not for authoring a brand-new skill from scratch (use creating-skill) or one-off prose.
Invokes Google Gemini models for structured outputs, image generation, multi-modal tasks, and Google-specific features. Use when users request Gemini, image generation, structured JSON output, Google API integration, or cost-effective parallel processing.
Convenes expert panels for problem-solving. Use when user mentions panel, experts, multiple perspectives, MECE, DMAIC, RAPID, Six Sigma, root cause analysis, strategic decisions, or process improvement.
DAG workflow runner that encodes control flow in code, not prose. Use when a procedure has 3+ steps with branching, retries, or validation that must be enforced — gates as `when=`, edge contracts as `validate=`, predicate loops as `retry_until=`. The runner owns the graph; the LLM provides leaves. Also covers parallel execution, checkpoint resume, detached side-effects.
Orchestrates parallel API instances, delegated sub-tasks, and multi-agent workflows with streaming and tool-enabled delegation patterns. Use for parallel analysis, multi-perspective reviews, or complex task decomposition.
Skill-aware orchestration with context routing. Decomposes complex tasks into skill-typed subtasks, extracts targeted context subsets, executes subagents in parallel, and synthesizes results. Self-answers trivial lookups inline. No SDK dependency — uses raw HTTP via httpx. Use when tasks require multiple analytical perspectives, when context is large and subtasks only need portions, or when orchestrating-agents spawns too many redundant subagents.
| name | challenging |
| description | Cross-context adversarial review for deliverables before shipping. Use when producing blog posts, technical recommendations, analysis briefs, code, or any artifact where accuracy matters more than speed. Triggers on "challenge this", "review before shipping", "adversarial pass", "stress test this". |
| metadata | {"version":"0.10.0"} |
Adversarial review before shipping. Three paths, each with distinct trade-offs:
The adversary='auto' resolution (default) picks gemini → claude → self based on available credentials. Callers in Claude Code still use prepare() + Task tool explicitly (subagent is strictly better than self in that environment, and auto-detection of Claude Code is brittle).
Inspired by VDD (dollspace.gay) and Grainulation's anti-rationalization patterns. The drill helper adopts the 5 Whys pattern from Tim Kellogg's open-strix writeup. The self-path persona-inhabitation move is kin to generative-thinking's inversion — commit to the mode before evaluating.
Pick the profile matching your artifact. Read only the profile you need — each is self-contained with persona, anti-rationalization table, evaluation criteria, and adversary system prompt.
| Profile | Use For | Iteration strategy | File |
|---|---|---|---|
prose | Blog posts, essays, articles — generic prose competence | parallel replay | references/prose.md |
prose-register | Prose with a named voice signature — fidelity check | parallel replay | references/prose-register.md |
analysis | Research briefs, comparisons, synthesis | parallel replay | references/analysis.md |
code | Scripts, implementations, PRs | parallel replay | references/code.md |
recommendation | Technical decisions, architecture choices | parallel replay | references/recommendation.md |
drill | 5 Whys on one finding from a review | sequential deepen | references/drill.md |
One engine, one surface, two iteration strategies. Review profiles iterate in parallel replay — each pass independent, novelty tracked for confabulation. Drill iterates in sequential deepen — each pass takes the chain so far and produces one more why-level until bedrock or max depth, followed by a synthesis pass that extracts root causes.
prose and prose-register are siblings, not redundant. prose evaluates generic prose competence (claims, logic, structure, performed insight) and is explicitly told not to comment on style. prose-register evaluates fidelity to a named voice signature passed via voice=... (positive markers + anti-patterns) and ignores generic competence. Run both passes on voiced prose — they catch different failure modes.
Two-step protocol: a Python helper builds the prompt, you spawn a subagent via the Task tool, then a parser turns its response into structured findings.
import sys
sys.path.insert(0, '/mnt/skills/user/challenging/scripts')
from challenger import prepare, parse_response
job = prepare(
artifact=open('/home/claude/draft.md').read(),
profile='prose',
context='Blog post about RAG scaling laws',
)
Then invoke the Task tool — subagent_type='general-purpose', prompt=job['prompt'], description='Adversarial review (prose)'. The subagent runs in a fresh context, applies the persona, and returns a JSON message. Pass that message text to the parser:
result = parse_response(subagent_text)
print(result['verdict']) # SHIP | REVISE | RETHINK
print(result['findings']) # List of specific issues
print(result['strengths']) # What to preserve
Why subagents (not the API): no key, no network dependency, fresh context, and the same Claude that's reviewing your work is reviewing it again with no prior bias — but in a clean window. For cross-model diversity (genuinely different blind spots), use Gemini below.
prose-register (subagent path)For prose written in a named voice, prose will miss register-specific failure modes by design (its persona is instructed not to comment on style). Use the prose-register profile with a voice=... signature instead — or in addition, since the two profiles target orthogonal failure modes.
voice = """
Corvid voice signature.
Positive markers: short sentences when certainty is high, dry observations,
lead with the answer then context, no throat-clearing.
Anti-patterns: heroic-narrator framing, drama-line-breaks ("Then the part that
almost killed it." floating alone), cliche tells ("shot itself in the foot",
"footgun"), time-scale inflation ("a month ago" when it was yesterday),
performed-significance setups ("What's interesting about this is..."),
RTFM-performed-as-revelation, precious sentimentality in closings.
"""
job = prepare(
artifact=open('/home/claude/draft.md').read(),
profile='prose-register',
context='Blog post for muninn.austegard.com',
voice=voice,
)
# Task tool → parse_response() as usual.
voice is required for prose-register and rejected for every other profile — pass the signature once, fail loud if it leaks to the wrong call. The richer the signature (with both positive markers and explicit anti-patterns), the more precise the review. A thin signature returns verdict: RETHINK with a finding describing what to sharpen rather than a confident review against an ambiguous spec.
Drill uses the same prepare() / Task / parse_response() protocol as review profiles, but you run the loop yourself — each pass takes the chain so far and produces exactly ONE new {why, because}. When the adversary sets bedrock=true (or you hit max depth), run a final synthesis pass.
from challenger import prepare, parse_response
suspect = next(f for f in result['findings'] if f['severity'] in ('high', 'critical'))
artifact = open('/home/claude/draft.md').read()
ctx = 'Blog post about RAG scaling laws'
chain = []
for depth in range(1, 6):
job = prepare(artifact, 'drill', context=ctx, finding=suspect, chain=chain)
# Task tool: subagent_type='general-purpose', prompt=job['prompt']
step = parse_response(subagent_text) # {why, because, bedrock, reasoning}
chain.append({'why': step['why'], 'because': step['because']})
if step.get('bedrock'):
break
# Final synthesis pass over the completed chain
job = prepare(artifact, 'drill', context=ctx, finding=suspect, chain=chain, synthesize=True)
# Task tool again, then:
diagnosis = parse_response(subagent_text)
print(diagnosis['chain']) # [{why, because}, ...]
print(diagnosis['root_causes']) # usually 3-4 distinct systemic issues
print(diagnosis['direction']) # compass heading for the process fix
finding accepts either a dict from parse_response() or a free-text description. Patches fix the instance; drills fix the class. Why sequential, not parallel? A single-shot drill lets the model shortcut the whole tree and produces renames instead of explanations; one level per pass forces each "because" to earn its depth. See references/drill.md for when to drill and the anti-patterns to reject.
Where subagents aren't available, call an external model directly.
from challenger import challenge
result = challenge(
artifact=open('draft.md').read(),
profile='prose',
context='Blog post about RAG scaling laws',
adversary='gemini', # default — cross-model diversity
)
adversary accepts:
auto (default) — resolves to gemini > claude > self based on available credentials. Logs the choice.gemini — Gemini 3.1 Pro. Cross-model + cross-context. Requires Gemini credentials.claude — Anthropic API. Cross-context, same model family. Do not use this in Claude Code — use the subagent path instead.self — NOT runnable via challenge() (raises with a pointer to prepare_self()). Self-challenge requires the caller assistant to produce the adversary response, which a synchronous function cannot do.Drill uses the same challenge() call with profile='drill'. challenge() runs the whole sequential-deepen loop internally and returns the synthesized diagnosis:
diagnosis = challenge(
artifact,
profile='drill',
context=ctx,
finding=suspect, # required for drill
max_iterations=5, # optional — defaults to 5 for drill, 3 for review
)
print(diagnosis['chain'], diagnosis['root_causes'], diagnosis['direction'])
result = challenge(artifact, profile='analysis', mode='blocking', max_iterations=3)
Loops the adversary until: (a) no actionable findings, (b) novelty rate > 75% (adversary inventing problems — artifact is clean), or (c) max iterations. mode is ignored when profile='drill' — drill always iterates until bedrock or max depth. Subagent-path callers can replicate blocking mode by looping prepare() / Task / parse_response() themselves and tracking findings across iterations.
When neither subagents nor external API credentials are available — or when subject-matter context from the current conversation is load-bearing for the review — use prepare_self(). The caller assistant inhabits the adversary persona in a dedicated response.
from challenger import prepare_self, parse_response
job = prepare_self(
artifact=open('draft.md').read(),
profile='analysis',
context='Cross-domain claim that depends on codebase-specific IEEE-754 conventions',
)
# job is {'system': <adversary system prompt>, 'user': <artifact + context>, ...}
The caller then:
job['system'] — the prompt opens with SELF-INVOCATION MODE instructing a full persona switch. Commit to it.parse_response().# After generating the adversary JSON in a dedicated response:
result = parse_response(adversary_json_text)
print(result['verdict'], result['findings'])
When self beats external: the artifact depends on conventions visible only from inside the conversation (codebase invariants, prior decisions, domain terminology established earlier). External adversaries with generic priors issue confident-but-wrong findings in these cases; self retains the context.
When external beats self: the artifact contains confabulations or blind spots the caller already committed to. Fresh context catches these; self inherits them.
When possible, run both. They have orthogonal failure modes.
Drill via self path uses the same loop as the subagent drill: iterate prepare_self(profile='drill', finding=..., chain=...) — produce one {why, because} per dedicated response — append to chain — until bedrock or max depth — then a final synthesize pass.
context to ground the adversary on APIs/patterns it may not know.The subagent path needs no credentials. The API path loads from environment or project files:
CF_ACCOUNT_ID, CF_GATEWAY_ID, CF_API_TOKEN from env or proxy.envGOOGLE_API_KEY from envANTHROPIC_API_KEY or API_KEY from env or claude.envNo external skill dependencies. requests is loaded lazily — only the API path requires it.