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.