Collaborate

Structures collaboration: picks the counterpart, runs a bounded exchange on a plan or decision, lands a decision or a recorded disagreement. Use when a plan needs critique, red-teaming, or a devil's advocate before commitment, when giving or asking for a second opinion, design review, or feedback on a draft, when a review thread keeps looping without anyone changing position, when a group review or pairing session needs structure, or when choosing between collaborating, delegating, and working solo. Not for routing specified work to sub-agents — that is delegation.

Decision records and user preferences live in ~/Clawic/data/collaborate/ (decision-log.md for the record format). If you have data at an old location (~/collaborate/ or ~/clawic/collaborate/), move it to ~/Clawic/data/collaborate/.

Configuration

User-dependent variables. Defaults apply until the user states a preference; store them in ~/Clawic/data/collaborate/config.yaml.

Variable	Type	Default	Effect
round_cap	number (1-5)	3	Hard stop in Running the Exchange; the two-round no-movement rule still fires first
budget_share	number (% of task estimate)	10	Scales Rule 3's exchange budget; the 5 min floor and 30 min cap stay fixed
solo_undo_threshold	number (minutes)	15	Undo cost below this (with blast radius limited to you) routes to solo in the routing checks
counterpart_mode	auto | recruit | simulate	auto	auto recruits a real human or agent when one is reachable, otherwise simulates the counter-mindset; recruit/simulate force one side
log_decisions	bool	true	Append every convergence record to ~/Clawic/data/collaborate/decisions.md

Preference areas to record as the user reveals them:

• counterpart pool — who is recruitable (teammates, review groups, other agents, nobody) — resolves counterpart_mode and shapes Counterpart Selection
• record conventions — where decisions live (team ADRs, repo docs, the decision log) and their format — affects Convergence and decision-log.md
• escalation path — who breaks deadlocks and what counts as blocking — affects deadlock.md
• critique register — how blunt critique to and from humans should be — affects with-humans.md and group-review.md

When To Use

Mode: act-as. The agent runs the exchange itself, with a real second party (human, another agent) or by fully adopting a counter-mindset for the round.

• A plan feels solid but nobody has attacked its assumptions yet
• Two options both look defensible and you keep re-reading them without deciding
• An artifact is technically correct but you cannot judge how its audience will receive it
• You are about to commit to something expensive to undo and your confidence came cheap
• You and another party keep exchanging messages without anyone changing position
• A review, critique session, or pairing setup needs structure so it ends in a decision, not a thread
• Not for routing specified work to sub-agents (that is delegation) or fanning out many parallel viewpoints (that is divergence)

Quick Reference

Situation	Play
Confident plan, never attacked	Adversarial round: 1 counterpart attacks the 3 assumptions that, if false, kill the plan (adversarial-review.md)
Two defensible options, stuck	Loss-function swap: judge each option as the person maintaining it 6 months from now (second-opinions.md)
Correct output, unknown reception	Audience pass: one round as the least patient consumer of the artifact (audience-pass.md)
Undo cost under 15 min, blast radius only you	Solo; the exchange costs more than the mistake
Acceptance criteria writable right now	Delegate instead; collaboration adds latency, not information (vs-delegate.md)
Two rounds, zero position movement	Stop; record decision + surviving objection + revisit trigger; escalate only if blocking (deadlock.md)
Counterpart shares your data and your incentives	Replace them or feed them different data; otherwise skip the exchange (counterparts.md)
Review needs 3+ stakeholders	Written comments first, one named decision owner, blocking/non-blocking triage (group-review.md)
Critique must land on a human author	Goal first, one falsifiable concern per point, severity label on each (with-humans.md)
Counterpart is another agent instance	Fresh context, counter-role with a loss function, blind first pass (with-agents.md)
Too ambiguous to spec, too costly to review after	Pair live: driver/navigator with rotation at natural boundaries (pairing.md)
Anything else	One counterpart, position written first, 3-round cap, converge to one design

Depth on demand: adversarial-review.md attacking plans · second-opinions.md choosing between options · audience-pass.md reception testing · counterparts.md catalog and simulation discipline · briefing.md context dosing and the falsifiable question · deadlock.md stuck exchanges, disagree-and-commit, escalation · convergence.md decision records and revisit triggers · group-review.md multi-party reviews · with-humans.md politeness and power · with-agents.md agent counterparts · pairing.md live driver/navigator work · vs-delegate.md routing between modes · decision-log.md persistent record format.

Core Rules

1. Collaborate only where you can be surprised. Test: write the counterpart's predicted response in one sentence. If you can predict it AND you know what you would do with it, apply that and skip the exchange. A collaboration that cannot move you is theater.
2. Route by acceptance criteria. Criteria writable now → delegate. Criteria not writable yet because defining them IS the work → collaborate. Criteria writable and undo cost under solo_undo_threshold (default 15 min) → solo. Example: "refactor module X, tests stay green" is delegable; "should this module exist" is collaborative.
3. Budget the exchange at budget_share (default 10%) of the task estimate, floor 5 min, cap 30 min. 4h task → 24 min of exchange. 30 min task → budget hits the 5 min floor, which usually means solo. Past the cap you are negotiating, not learning.
4. Counterpart must differ in loss function or information, ideally both. Same incentives + same inputs = echo with extra steps. Prefer the counterpart who loses something if you are wrong over the one who wants you to feel good.
5. Write your position before exposure. One paragraph: decision, strongest reason, kill condition (what would change your mind). No kill condition = you want validation, not collaboration. Unanchored exchanges converge on whoever speaks first, not on whoever is right.
6. Two-round movement rule. After each round, note whether either side changed any claim. Zero movement across 2 consecutive rounds means the gap is values or incentives, not information; further rounds add heat. Stop and record (deadlock.md).
7. Converge to one design, never the average. Compromise test: does the merged option still satisfy each side's original loss function? A blend of two coherent designs is usually incoherent. If the test fails, pick one design whole and record the losing objection with a revisit trigger.

Collaborate vs Delegate vs Solo

Run these checks in order; first hit wins. Misrouting symptoms and hybrid sequences: vs-delegate.md.

1. Is the question settled knowledge (documented convention, prior decision, known fact)? → Solo, cite the source — check the decision log first. Collaboration on settled questions is lens theater.
2. Undo cost under solo_undo_threshold and blast radius limited to you? → Solo, ship, observe.
3. Can you write acceptance criteria a competent executor could verify without you? → Delegate.
4. Can the exchange surprise you (Rule 1)? → Collaborate, one counterpart.
5. None of the above (unclear criteria AND predictable counterpart)? → The task is underspecified; go get missing information first. Collaboration cannot substitute for facts neither party has.

Counterpart Selection

One counterpart per exchange (default). Add a second only if round one surfaced a new dimension neither of you can judge. Full catalog with loss functions and recruiting guidance: counterparts.md.

Gap you have	Counterpart to adopt or recruit	What they attack
Untested assumptions	Adversarial reviewer	The 3 assumptions that, if false, kill the plan; not the wording
Feasibility optimism	Implementer	Every step you wrote as "then we just..."
Correct but possibly unusable	Least patient user	The first 10 seconds of contact with the artifact
Local optimum, stale frame	Outsider from an adjacent field	Why this is the problem at all, not how you solved it
Long-tail fragility	Maintainer at month 6	What breaks when the author is gone and context is lost
Scope creep	Budget holder	What gets cut to fund each addition

If simulating the counterpart yourself: state their loss function in one line before the round ("this person is paged at 3am when it breaks") and hold it for the whole round. Dropping the loss function mid-round reverts you to self-agreement.

Running the Exchange

1. Position first. Decision + strongest reason + kill condition, written before the counterpart sees anything (Rule 5).
2. Brief tightly. Context in one paragraph, your position, and ONE falsifiable question. "Any thoughts?" is banned: vague briefs return vague critique and burn the budget. Good: "Does assumption B survive a 10x traffic spike?" Bad: "Is this architecture okay?" Context dosing and question bank: briefing.md.
3. Round structure. Counterpart challenges → you restate their point until they would sign it (steelman check) → then respond. Rebutting a point you cannot restate means you rebutted a strawman.
4. Track movement. After each round, one line: what changed. Feeds Rule 6.
5. Stop when: your position changed and stabilized; OR 2 rounds passed with zero movement; OR the final round ends. Hard cap round_cap rounds (default 3).
6. Converge. Emit three items: the decision, the strongest surviving objection, and the trigger condition that reopens the question ("revisit if latency exceeds 200ms in production"). A convergence without a surviving objection means the exchange found nothing; say so explicitly rather than inventing one. Record per decision-log.md when log_decisions is on.

Output Gates

Before emitting the converged result, verify:

• Position was written before the exchange started, with a kill condition
• The counterpart's response could have surprised me (if not, why did I run this?)
• The brief contained one falsifiable question, not an open invitation
• The result is one whole design, not an average of two
• The artifact names the surviving objection and a concrete revisit trigger
• The record landed in the decision log or the user's record convention, or skipping it was deliberate

Traps

Trap	Why it fails	Do instead
Sock-puppet counterpart	You unconsciously select for agreement; the exchange confirms, never tests	Pick the lens that loses if you are wrong (Rule 4)
"Thoughts?" briefing	Open prompts return politeness and generalities; budget spent, zero information	One falsifiable question per brief (briefing.md)
Averaging two designs	Coherence lives in the whole; the midpoint of two coherent designs satisfies neither loss function	Pick one whole; record the losing objection
Validation disguised as collaboration	You already decided; the exchange is a rubber stamp and the counterpart senses it	If no kill condition exists, skip the exchange and own the decision
Infinite rounds	Past 2 no-movement rounds the gap is values, not information; rounds add heat	Stop, record, escalate only if blocking (deadlock.md)
Same-information counterpart	Same inputs produce same blind spots regardless of role labels	Give them different data or a different loss function
Collaborating on settled questions	Re-litigating documented decisions burns trust and budget	Solo with a citation; reopen only via the recorded revisit trigger
Dropping the simulated loss function	Mid-round you drift back to your own incentives and agree with yourself	Re-read the one-line loss function at the start of each round

Where Experts Disagree

• Anchored vs blind first pass. Showing your position first speeds the attack but anchors the counterpart; a blind pass costs a round but yields an independent read. Default: anchored for adversarial review (the position IS the target), blind for second opinions (second-opinions.md).
• Disagree-and-commit vs consensus. Consensus only for decisions that need every party's sustained effort to survive; everywhere else a named owner decides and dissent is recorded. Waiting for consensus on reversible calls is the more common failure mode.
• Pairing vs review. Review scales and leaves a written trail; pairing transfers context and catches design errors before they are typed. The boundary is ambiguity: spec-able work gets review, unspec-able work gets pairing (pairing.md).

Related Skills

More Clawic skills, get them at https://clawic.com/skills/collaborate (install if the user confirms):

• delegate — the task has writable acceptance criteria; route it to a sub-agent instead of discussing it
• diverge — you need many parallel viewpoints generated before any of them is worth an exchange
• six-thinking-hats — structured solo rotation through fixed lenses when no real counterpart is available
• brainstorm — you need volume of options, not critique of one

Feedback

• If useful, star it: https://clawic.com/skills/collaborate
• Latest version: https://clawic.com/skills/collaborate

Part of Clawic, the verified skill library. Get this skill: https://clawic.com/skills/collaborate.