debate

Generate and evaluate three design options with a five-criterion comparison matrix.

8|1|Updated Jan 24, 2026
One-click install
npx skills add https://github.com/bordenet/superpowers-plus --skill debate-bordenet
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: debate
Source: https://github.com/bordenet/superpowers-plus/tree/main/skills/engineering/debate
Command: npx skills add https://github.com/bordenet/superpowers-plus --skill debate-bordenet

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Prevents premature design commitments and shallow decisions by forcing generation of multiple distinct options, a structured comparison, adversarial red-teaming, and verified fixes before declaring a chosen architecture.

Core Features & Use Cases

  • Generate multiple options: Produce at least three genuinely different, implementable design alternatives.
  • Structured comparison: Create a concise matrix across five criteria to surface trade-offs.
  • Harsh adversarial review: Require a separate hostile reviewer (sub-agent or explicit role switch) to probe assumptions and failure modes, then enumerate edge cases and perform at least two fix+re-review iterations.
  • Use Cases: Choosing integration patterns, selecting data models, evaluating architecture trade-offs, or self-triggering before committing to an implementation.

Quick Start

Compare three distinct design approaches for the proposed feature and run the debate process to generate options, a comparison matrix, a harsh review, edge-case findings, and two review iterations with verified fixes.

Frequently Asked Questions about debate

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I evaluate multiple architecture design options before committing to an implementation?

Evaluating architecture design options involves generating at least three distinct alternatives, structuring them into a five-criterion comparison matrix, and running an adversarial review to probe assumptions before implementation. This process surfaces trade-offs and prevents premature commitments.

What is an adversarial red-team review for software architecture decisions?

An adversarial red-team review is a structured evaluation where a separate hostile reviewer probes your design assumptions and failure modes. It requires enumerating edge cases and performing at least two fix and re-review iterations to verify architectural resilience before finalizing the decision.

How do I create a comparison matrix to choose between integration patterns or data models?

Creating a comparison matrix for integration patterns requires evaluating at least three distinct design options across five specific criteria. This structured approach surfaces trade-offs between data models and architectural approaches, ensuring a verified, well-rounded selection.

When do I need to generate multiple design alternatives for a proposed feature?

You need to generate multiple design alternatives whenever you are choosing between architectural patterns, data models, or integration approaches. Producing three or more options prevents shallow decision-making and ensures edge cases are catalogued before committing to implementation.

Does this architectural decision process handle edge-case discovery and verification?

Yes, the architectural decision process handles edge-case discovery by requiring a harsh adversarial reviewer to probe failure modes. It mandates cataloguing these edge cases and performing a minimum of two review rounds with applied fixes and verification.

What is the best way to prevent premature design commitments in software architecture?

The best way to prevent premature design commitments is to enforce a structured debate process that requires generating three or more distinct options, applying a five-criterion comparison matrix, and completing two verified adversarial review iterations before declaring a chosen architecture.