What is dialectic used for?

To prove and counter-prove a statement by running two opposing agents in parallel, surfacing concrete evidence, and synthesizing an objective conclusion.

How does it ensure objectivity?

By requiring specific file paths/line references, a synthesis check against the actual code, and verification before presenting conclusions.

What if the synthesis contradicts the code?

Revisit the sources, adjust interpretation, and run additional verification to ensure conclusions reflect the actual implementation.

dialectic

Scanned

npx machina-cli add skill umputun/cc-thingz/dialectic --openclaw

Files (1)

SKILL.md

3.0 KB

Dialectic Analysis

Objective analysis of a statement by running two agents with opposing goals in parallel, then synthesizing findings.

Process

Step 1: Launch Parallel Agents

CRITICAL: Both Task tool calls MUST be in a single message for true parallel execution. Do NOT use run_in_background. Do NOT launch sequentially. Foreground agents in the same message run in parallel and block until both complete.

Agent 1 (Thesis) — find all POSITIVE evidence:

what works well, improvements, correct patterns
supporting facts, proof the statement is TRUE
benefits, strengths, successful outcomes

Agent 2 (Antithesis) — find all NEGATIVE evidence:

what's problematic, issues, risks, anti-patterns
edge cases, proof the statement is FALSE
weaknesses, failure modes, hidden costs

Both agents must provide specific file paths and line numbers when analyzing code.

Step 2: Synthesize

After both agents complete, synthesize findings into an objective conclusion:

weigh evidence from both sides
identify where thesis and antithesis agree (strongest signal)
note unresolved tensions

Step 3: Verify

CRITICAL — after presenting the synthesis, verify it against actual implementation:

read the specific files and line numbers referenced by both agents
confirm the evidence cited actually exists in the codebase
check the implementation flow matches the claims made
verify the synthesis accurately reflects the actual code context
identify any misinterpretations or missing context from agent reports
revise synthesis if verification reveals inaccuracies

Use Cases

Architecture decisions:

/thinking-tools:dialectic this microservice split improves maintainability

Bug analysis:

/thinking-tools:dialectic the connection pool fixes the timeout issue

Performance claims:

/thinking-tools:dialectic caching reduced database load by 80%

Refactoring safety:

/thinking-tools:dialectic extracting this interface simplifies testing

Code review:

/thinking-tools:dialectic this implementation is thread-safe

Review changes:

/thinking-tools:dialectic review the changes in server.go

Key Principles

Eliminate confirmation bias — examining both sides simultaneously prevents anchoring on the first conclusion
Evidence-based — agents must cite specific files, lines, and facts, not general claims
Verification required — synthesis must be checked against actual code before presenting
Objective conclusion — the goal is truth, not winning either side

Source

git clone https://github.com/umputun/cc-thingz/blob/master/plugins/thinking-tools/skills/dialectic/SKILL.mdView on GitHub

Overview

Dialectic Analysis runs two agents with opposing goals in parallel to assess a claim. It surfaces positive and negative evidence with concrete file references, then synthesizes an objective conclusion and verifies it against the actual codebase.

How This Skill Works

Two agents are launched in parallel within a single message: Thesis searches for positive evidence and Antithesis uncovers negative evidence, both citing specific files and lines. The results are synthesized into an objective conclusion, weighing evidence from both sides. Finally, a verification step reads the referenced files to ensure the synthesis matches the real implementation.

When to Use It

Architecture decisions
Bug analysis
Performance claims
Refactoring safety
Code review

Quick Start

Step 1: Define the claim to analyze via the agent prompt.
Step 2: Launch Thesis (positive) and Antithesis (negative) in a single message.
Step 3: Read the synthesis and run verification against the referenced files/lines.

Best Practices

Require specific file paths and line numbers from both Thesis and Antithesis.
Cite concrete evidence and avoid vague claims; reference exact files/lines.
Run Thesis and Antithesis in a single message to ensure true parallelism.
Include a synthesis verification step against the actual codebase.
Document unresolved tensions and iterate if new evidence emerges.

Example Use Cases

/thinking-tools:dialectic this microservice split improves maintainability
/thinking-tools:dialectic the connection pool fixes the timeout issue
/thinking-tools:dialectic caching reduced database load by 80%
/thinking-tools:dialectic extracting this interface simplifies testing
/thinking-tools:dialectic this implementation is thread-safe

Frequently Asked Questions

Add this skill to your agents