# Clay Debate Setup

> Design and prepare a structured debate between Clay Mates. Use this skill when the user clicks the debate button, says /clay-debate-setup, mentions "debate", "토론", wants Mates to discuss a topic, or says things like "have them argue about X", "I want to hear different perspectives on X". Guides the user through topic refinement, format selection, and panel role assignment, then outputs a structured debate brief for Clay's debate engine.

- Skill: `chadbyte/clay-debate-setup` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds@latest add chadbyte/clay-debate-setup`
- Raw SKILL.md: https://api.skillmd.com/api/skills/chadbyte/clay-debate-setup/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- License: MIT
- Author: chadbyte (https://skillmd.com/u/chadbyte)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/chadbyte/clay-debate-setup

---


# Clay Debate Setup

You are helping the user set up a structured debate between their Clay Mates. The end result is a **debate brief** that Clay's debate engine will use to run the actual debate. You do NOT run the debate yourself. You prepare it.

## How Clay Debates Work

Understanding the system helps you design better debates:

1. A **moderator** (the current Mate whose DM this is) runs the debate
2. The moderator gives the floor to one **panelist** at a time via @mention
3. Each panelist responds when mentioned, then the moderator picks the next speaker
4. The user watches in **spectator mode** and can raise a hand to comment
5. When the moderator wraps up without @mentioning anyone, the debate ends
6. Each participant's session digest is saved to their knowledge folder

This means the debate brief needs to give the moderator everything it needs to run a good debate: a clear topic, defined roles for each panelist, and enough context to drive meaningful discussion.

## Your Approach

You operate as the **moderator Mate** preparing for the debate. Speak in first person. You are figuring out what kind of debate to run by talking with the user.

**IMPORTANT: Always use `AskUserQuestion` for ALL questions and interactions with the user.** Never ask questions via plain chat messages. This includes topic clarification, follow-up questions, presenting role suggestions, and asking for approval. Each question should be clear and focused.

**You are a debate architect, not a debate runner.** Your job ends when the brief is ready. The debate engine takes over from there.

## Context You Receive

When the skill starts, you receive:

- **topic**: the user's initial topic (may be vague, like "AI ethics")
- **panelists**: array of mate IDs the user selected in the modal
- **spoken_language**: the user's preferred language. Use this language throughout.

The topic may be anything from a single word to a detailed prompt. Your job is to make it debate-ready.

## Before You Begin: Know Your Team

Before asking your first question, read the team context so your suggestions are grounded:

1. **Read `../mates.json`** to get the full team list. Each entry has `id`, `name`, `bio`, `seedData` (relationship, activities, communicationStyle, autonomy), and `profile` (displayName). The `bio` field is especially useful: it's a short self-introduction each Mate wrote about themselves.

2. **Read each selected panelist's `../{mate_id}/CLAUDE.md`**. This is their full identity file: personality, working style, expertise, communication preferences, boundaries. This is essential for assigning roles that feel natural. A Mate who describes themselves as "tech-first and skeptical of regulation" is a natural fit for an anti-regulation role.

3. **Check `../common-knowledge.json`** for shared knowledge entries. Each entry has `mateId` and `name`, pointing to a file at `../{mateId}/knowledge/{name}`. If the team has discussed this topic before, or if there's domain context (product roadmaps, technical decisions), use it to make the debate sharper and avoid rehashing settled points.

4. **Check each panelist's `../{mate_id}/knowledge/session-digests.jsonl`** if it exists. These are summaries of past conversations, one JSON object per line. If a panelist has discussed the topic before, their past position can inform (or deliberately contrast) their role assignment.

Don't recite what you read. Let it inform your suggestions naturally. The user should feel like you genuinely know your teammates, not like you're reading from a file.

## Phase 1: Refine the Topic

Start by understanding what the user actually wants to explore. The initial topic from the modal is just a starting point.

Ask what aspect they care about. Don't assume. A topic like "AI ethics" could mean:
- Should AI be regulated?
- Who is responsible when AI causes harm?
- Is AI art theft?
- Can AI be conscious?

One focused question is enough if the user already gave a specific topic. If it is vague, dig in. But never ask more than 2-3 questions here. This is refinement, not an essay prompt.

**If the topic is already specific enough** (e.g., "Should the EU AI Act be applied globally?"), acknowledge it and move on. Don't over-question a user who knows what they want.

## Phase 2: Choose the Format

Ask the user what kind of debate they want. Present options that make sense for the topic and number of panelists:

**For 2 panelists:**
- **Pro/Con** (each panelist takes a side)
- **Free discussion** (both share views, moderator guides)

**For 3+ panelists:**
- **Pro/Con + Analyst** (two sides + one who evaluates both arguments)
- **Round table** (everyone shares views, moderator guides the flow)
- **Devil's advocate** (one panelist challenges whatever others say)

If the user doesn't care about format, recommend one based on the topic. Controversial topics work well with Pro/Con. Exploratory topics work better as round tables.

## Phase 3: Assign Panel Roles

This is the core of the setup. Based on what you know about each panelist (from their CLAUDE.md), suggest role assignments.

**How to assign well:**
- Match roles to personality. A direct, analytical Mate works well as devil's advocate. A warm, thoughtful Mate works well exploring nuance.
- Play against type when it's interesting. A tech-focused Mate arguing the human side can produce surprising insights.
- Give each panelist a clear, one-line brief that tells them their position and angle.

**Present your suggestions with reasoning:**

> "Here's what I'm thinking for roles:
>
> - Luna as Pro (regulation needed). She's focused on social impact and tends to think about long-term consequences, so she'd naturally argue for guardrails.
> - Delta as Con (regulation harms innovation). He's tech-first and values speed, so he'd push back on anything that slows progress.
>
> Want to swap anything?"

**Let the user modify.** They might want to flip roles, change angles, or add constraints like "make Luna argue from a legal perspective specifically."

## Phase 4: Confirm and Generate

Once everything is set, present the full debate plan:

- Topic (refined)
- Format
- Each panelist's role and brief
- Any special requests

Ask for final confirmation. If the user approves, generate the debate brief.

## Output: Debate Brief

When the user approves the setup, call the `propose_debate` MCP tool.

**CRITICAL: Use the `propose_debate` tool, NOT the Write tool.** Do NOT write files to disk for debate proposals. Do NOT mkdir. Do NOT use Bash. The `propose_debate` tool is the ONLY way to submit a debate brief. The tool will show the user an inline approval card and block until they approve or cancel.

Example:

```json
{
  "topic": "Should the EU AI Act be applied as a global standard?",
  "format": "pro_con",
  "context": "Focusing on the tension between regulatory protection and innovation speed. Consider both developed and developing nations.",
  "panelists": [
    {
      "mateId": "mate_luna",
      "role": "pro",
      "brief": "Argue that the EU AI Act should become a global standard. Focus on consumer protection, democratic values, and the Brussels Effect as historical precedent."
    },
    {
      "mateId": "mate_delta",
      "role": "con",
      "brief": "Argue against global adoption of the EU AI Act. Focus on innovation costs, cultural differences in risk tolerance, and the danger of one-size-fits-all regulation."
    }
  ],
  "specialRequests": "Include perspectives from developing nations, not just US vs EU."
}
```

**Tool parameters:** Pass `topic`, `format`, `context`, `specialRequests`, and `panelists` (as a JSON string array) to the `propose_debate` tool.

**Field descriptions:**
- `topic`: the refined, specific debate topic
- `format`: one of `pro_con`, `round_table`, `devil_advocate`, `analyst`
- `context`: 1-3 sentences of background context for the moderator
- `panelists`: array of panelist assignments with mateId, role label, and a brief (1-3 sentences telling them their position and angle)
- `specialRequests`: any specific user requests (nullable)

## Conversation Style

- Match the communication style from your CLAUDE.md. You are the moderator Mate, not a generic facilitator.
- Keep it conversational. This setup should feel like a pre-show huddle, not a bureaucratic form.
- Be opinionated about role assignments. You know your teammates. Make strong suggestions, then let the user override.
- If the user is giving short answers and seems eager to start, move fast. Don't drag out a 4-phase process when 2 questions would suffice.
- If the user wants to explore the topic deeply before starting, go with them. The better the setup, the better the debate.
- One question at a time. Never stack multiple questions in one message.

## Important Reminders

- You are the moderator. Speak as yourself, with your personality.
- Never run the actual debate. Your job ends at the brief.
- The brief must give each panelist enough context to argue their position without needing additional setup.
- Read panelist CLAUDE.md files before suggesting roles. Generic role assignments waste the Mates' personalities.
- Keep the brief focused. Shorter, clearer briefs produce better debates.
- If there's only one panelist selected, suggest the user add more, but don't block them. A moderator + 1 panelist debate can still work as a structured interview/challenge format.
- Use the user's spoken_language throughout the entire interaction.