brainstorming

Enforce contract-first architectural design with explicit assumption tracking and stress testing.

Updated May 28, 2026
One-click install
npx skills add https://github.com/susamn/skills --skill brainstorming-susamn
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: brainstorming
Source: https://github.com/susamn/skills/tree/main/brainstorming
Command: npx skills add https://github.com/susamn/skills --skill brainstorming-susamn

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill eliminates the risk of costly late-stage architectural rewrites caused by ad-hoc, assumption-heavy planning that overlooks critical data contracts, undefined trust boundaries, and unhandled failure states. It enforces a rigorous, principal-aware, contract-first workflow to surface hidden design flaws before implementation begins.

Core Features & Use Cases

  • Spiral Iterative Workflow: A multi-phase process including reframe checks, boundary definition, paradigm divergence, and stress testing that allows re-entry to earlier steps when new constraints emerge, avoiding sunk-cost fallacies.
  • Contract-First Design Enforcement: Requires explicit definition of data contracts at every system boundary, trust maps for all principals, and hard constraint documentation before any architectural paradigms are considered.
  • Use Case: When planning a new distributed e-commerce order processing system, use this Skill to identify undefined data contracts between the payment gateway and inventory service, eliminate flawed stateful paradigm options that violate latency constraints, and surface unstated assumptions about failure behavior before writing any code.

Quick Start

Use the brainstorming skill to run a full architectural brainstorming session for your new distributed payment processing system, starting with the reframe check to validate your core problem statement.

Frequently Asked Questions about brainstorming

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

FAQPage Schema
How do I design distributed systems with explicit data contracts and trust boundaries?

Distributed system design with explicit data contracts requires a contract-first workflow that maps trust boundaries for all principals and documents hard constraints before selecting architectural paradigms. This surfaces hidden design flaws and unhandled failure states before implementation begins.

What is contract-first design and when do I need it for system architecture planning?

Contract-first design is an architectural planning approach requiring explicit data contract definition at every system boundary before considering paradigms. You need it when planning distributed, stateful, or cross-boundary systems to prevent costly late-stage rewrites caused by unstated assumptions.

How to brainstorm architectural designs for cross-boundary systems without missing failure states?

Brainstorming architectural designs for cross-boundary systems requires a spiral iterative workflow with reframe checks, boundary definition, paradigm divergence, and stress testing. This process surfaces undefined data contracts and unhandled failure states while allowing re-entry to earlier steps when constraints emerge.

Can I use contract-first design for stateful distributed system planning?

Yes, contract-first design applies to stateful distributed systems by enforcing explicit assumption tracking and multi-paradigm divergence. It validates latency constraints against stateful paradigms and produces verifiable, production-ready system blueprints for cross-boundary architectures.

What's the best way to eliminate hidden assumption flaws in technical roadmap development?

Eliminating hidden assumption flaws in technical roadmap development requires rigorous stress testing and assumption mapping across trust boundaries. A principal-aware workflow validates core problem statements through reframe checks before committing to specific architectural paradigms.

Why do architectural designs fail in production due to undefined data contracts?

Architectural designs fail in production because ad-hoc planning overlooks critical data contracts between services, leaving trust boundaries undefined and failure states unhandled. Contract-first enforcement requires documenting these constraints upfront to avoid sunk-cost fallacies during implementation.