bmad-studio 0.1.0

package/_bmad/bmm/workflows/bmad-quick-flow/bmad-quick-spec/steps/step-03-generate.md

@@ -0,0 +1,123 @@
+---
+wipFile: '{implementation_artifacts}/tech-spec-wip.md'
+---
+
+# Step 3: Generate Implementation Plan
+
+**Progress: Step 3 of 4** - Next: Review & Finalize
+
+## RULES:
+
+- MUST NOT skip steps.
+- MUST NOT optimize sequence.
+- MUST follow exact instructions.
+- MUST NOT implement anything - just document.
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+## CONTEXT:
+
+- Requires `{wipFile}` with defined "Overview" and "Context for Development" sections.
+- Focus: Create the implementation sequence that addresses the requirement delta using the captured technical context.
+- Output: Implementation-ready tasks with specific files and instructions.
+- Target: Meet the **READY FOR DEVELOPMENT** standard defined in `workflow.md`.
+
+## SEQUENCE OF INSTRUCTIONS
+
+### 1. Load Current State
+
+**Read `{wipFile}` completely and extract:**
+
+- All frontmatter values
+- Overview section (Problem, Solution, Scope)
+- Context for Development section (Patterns, Files, Decisions)
+
+### 2. Generate Implementation Plan
+
+Generate specific implementation tasks:
+
+a) **Task Breakdown**
+
+- Each task should be a discrete, completable unit of work
+- Tasks should be ordered logically (dependencies first)
+- Include the specific files to modify in each task
+- Be explicit about what changes to make
+
+b) **Task Format**
+
+```markdown
+- [ ] Task N: Clear action description
+  - File: `path/to/file.ext`
+  - Action: Specific change to make
+  - Notes: Any implementation details
+```
+
+### 3. Generate Acceptance Criteria
+
+**Create testable acceptance criteria:**
+
+Each AC should follow Given/When/Then format:
+
+```markdown
+- [ ] AC N: Given [precondition], when [action], then [expected result]
+```
+
+**Ensure ACs cover:**
+
+- Happy path functionality
+- Error handling
+- Edge cases (if relevant)
+- Integration points (if relevant)
+
+### 4. Complete Additional Context
+
+**Fill in remaining sections:**
+
+a) **Dependencies**
+
+- External libraries or services needed
+- Other tasks or features this depends on
+- API or data dependencies
+
+b) **Testing Strategy**
+
+- Unit tests needed
+- Integration tests needed
+- Manual testing steps
+
+c) **Notes**
+
+- High-risk items from pre-mortem analysis
+- Known limitations
+- Future considerations (out of scope but worth noting)
+
+### 5. Write Complete Spec
+
+a) **Update `{wipFile}` with all generated content:**
+
+- Ensure all template sections are filled in
+- No placeholder text remaining
+- All frontmatter values current
+- Update status to 'review' (NOT 'ready-for-dev' - that happens after user review in Step 4)
+
+b) **Update frontmatter:**
+
+```yaml
+---
+# ... existing values ...
+status: 'review'
+stepsCompleted: [1, 2, 3]
+---
+```
+
+c) **Read fully and follow: `./step-04-review.md` (Step 4)**
+
+## REQUIRED OUTPUTS:
+
+- Tasks MUST be specific, actionable, ordered logically, with files to modify.
+- ACs MUST be testable, using Given/When/Then format.
+- Status MUST be updated to 'review'.
+
+## VERIFICATION CHECKLIST:
+
+- [ ] `stepsCompleted: [1, 2, 3]` set in frontmatter.
+- [ ] Spec meets the **READY FOR DEVELOPMENT** standard.

package/_bmad/bmm/workflows/bmad-quick-flow/bmad-quick-spec/steps/step-04-review.md

@@ -0,0 +1,195 @@
+---
+wipFile: '{implementation_artifacts}/tech-spec-wip.md'
+---
+
+# Step 4: Review & Finalize
+
+**Progress: Step 4 of 4** - Final Step
+
+## RULES:
+
+- MUST NOT skip steps.
+- MUST NOT optimize sequence.
+- MUST follow exact instructions.
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+## CONTEXT:
+
+- Requires `{wipFile}` from Step 3. 
+- MUST present COMPLETE spec content. Iterate until user is satisfied.
+- **Criteria**: The spec MUST meet the **READY FOR DEVELOPMENT** standard defined in `workflow.md`.
+
+## SEQUENCE OF INSTRUCTIONS
+
+### 1. Load and Present Complete Spec
+
+**Read `{wipFile}` completely and extract `slug` from frontmatter for later use.**
+
+**Present to user:**
+
+"Here's your complete tech-spec. Please review:"
+
+[Display the complete spec content - all sections]
+
+"**Quick Summary:**
+
+- {task_count} tasks to implement
+- {ac_count} acceptance criteria to verify
+- {files_count} files to modify"
+
+**Present review menu:**
+
+Display: "**Select:** [C] Continue [E] Edit [Q] Questions [A] Advanced Elicitation [P] Party Mode"
+
+**HALT and wait for user selection.**
+
+#### Menu Handling Logic:
+
+- IF C: Proceed to Section 3 (Finalize the Spec)
+- IF E: Proceed to Section 2 (Handle Review Feedback), then return here and redisplay menu
+- IF Q: Answer questions, then redisplay this menu
+- IF A: Invoke the `bmad-advanced-elicitation` skill with current spec content, process enhanced insights, ask user "Accept improvements? (y/n)", if yes update spec then redisplay menu, if no keep original then redisplay menu
+- IF P: Invoke the `bmad-party-mode` skill with current spec content, process collaborative insights, ask user "Accept changes? (y/n)", if yes update spec then redisplay menu, if no keep original then redisplay menu
+- IF Any other comments or queries: respond helpfully then redisplay menu
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to finalize when user selects 'C'
+- After other menu items execution, return to this menu
+
+### 2. Handle Review Feedback
+
+a) **If user requests changes:**
+
+- Make the requested edits to `{wipFile}`
+- Re-present the affected sections
+- Ask if there are more changes
+- Loop until user is satisfied
+
+b) **If the spec does NOT meet the "Ready for Development" standard:**
+
+- Point out the missing/weak sections (e.g., non-actionable tasks, missing ACs).
+- Propose specific improvements to reach the standard.
+- Make the edits once the user agrees.
+
+c) **If user has questions:**
+
+- Answer questions about the spec
+- Clarify any confusing sections
+- Make clarifying edits if needed
+
+### 3. Finalize the Spec
+
+**When user confirms the spec is good AND it meets the "Ready for Development" standard:**
+
+a) Update `{wipFile}` frontmatter:
+
+   ```yaml
+   ---
+   # ... existing values ...
+   status: 'ready-for-dev'
+   stepsCompleted: [1, 2, 3, 4]
+   ---
+   ```
+
+b) **Rename WIP file to final filename:**
+   - Using the `slug` extracted in Section 1
+   - Rename `{wipFile}` → `{implementation_artifacts}/tech-spec-{slug}.md`
+   - Store this as `finalFile` for use in menus below
+
+### 4. Present Final Menu
+
+a) **Display completion message and menu:**
+
+```
+**Tech-Spec Complete!**
+
+Saved to: {finalFile}
+
+---
+
+**Next Steps:**
+
+[A] Advanced Elicitation - refine further
+[R] Adversarial Review - critique of the spec (highly recommended)
+[B] Begin Development - start implementing now (not recommended)
+[D] Done - exit workflow
+[P] Party Mode - get expert feedback before dev
+
+---
+
+Once you are fully satisfied with the spec (ideally after **Adversarial Review** and maybe a few rounds of **Advanced Elicitation**), it is recommended to run implementation in a FRESH CONTEXT for best results.
+
+Copy this prompt to start dev:
+
+\`\`\`
+quick-dev {finalFile}
+\`\`\`
+
+This ensures the dev agent has clean context focused solely on implementation.
+```
+
+b) **HALT and wait for user selection.**
+
+#### Menu Handling Logic:
+
+- IF A: Invoke the `bmad-advanced-elicitation` skill with current spec content, process enhanced insights, ask user "Accept improvements? (y/n)", if yes update spec then redisplay menu, if no keep original then redisplay menu
+- IF B: Invoke the `bmad-quick-dev` skill with `{finalFile}` in a fresh context if possible (warn: fresh context is better)
+- IF D: Exit workflow - display final confirmation and path to spec
+- IF P: Invoke the `bmad-party-mode` skill with current spec content, process collaborative insights, ask user "Accept changes? (y/n)", if yes update spec then redisplay menu, if no keep original then redisplay menu
+- IF R: Execute Adversarial Review (see below)
+- IF Any other comments or queries: respond helpfully then redisplay menu
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- After A, P, or R execution, return to this menu
+
+#### Adversarial Review [R] Process:
+
+1. **Invoke Adversarial Review Skill**:
+       > With `{finalFile}` constructed, invoke the `bmad-review-adversarial-general` skill. If possible, use information asymmetry: invoke the skill in a separate subagent or process with read access to the project, but no context except the `{finalFile}`.
+       > Pass `{finalFile}` as the content to review. The skill should return a list of findings.
+
+    2. **Process Findings**:
+       > Capture the findings from the skill output.
+       > **If zero findings:** HALT - this is suspicious. Re-analyze or request user guidance.
+       > Evaluate severity (Critical, High, Medium, Low) and validity (real, noise, undecided).
+       > DO NOT exclude findings based on severity or validity unless explicitly asked to do so.
+       > Order findings by severity.
+       > Number the ordered findings (F1, F2, F3, etc.).
+       > If TodoWrite or similar tool is available, turn each finding into a TODO, include ID, severity, validity, and description in the TODO; otherwise present findings as a table with columns: ID, Severity, Validity, Description
+
+    3. Return here and redisplay menu.
+
+### 5. Exit Workflow
+
+**When user selects [D]:**
+
+"**All done!** Your tech-spec is ready at:
+
+`{finalFile}`
+
+When you're ready to implement, run:
+
+```
+quick-dev {finalFile}
+```
+
+Ship it!"
+
+---
+
+## REQUIRED OUTPUTS:
+
+- MUST update status to 'ready-for-dev'.
+- MUST rename file to `tech-spec-{slug}.md`.
+- MUST provide clear next-step guidance and recommend fresh context for dev.
+
+## VERIFICATION CHECKLIST:
+
+- [ ] Complete spec presented for review.
+- [ ] Requested changes implemented.
+- [ ] Spec verified against **READY FOR DEVELOPMENT** standard.
+- [ ] `stepsCompleted: [1, 2, 3, 4]` set and file renamed.

package/_bmad/bmm/workflows/bmad-quick-flow/bmad-quick-spec/tech-spec-template.md

@@ -0,0 +1,74 @@
+---
+title: '{title}'
+slug: '{slug}'
+created: '{date}'
+status: 'in-progress'
+stepsCompleted: []
+tech_stack: []
+files_to_modify: []
+code_patterns: []
+test_patterns: []
+---
+
+# Tech-Spec: {title}
+
+**Created:** {date}
+
+## Overview
+
+### Problem Statement
+
+{problem_statement}
+
+### Solution
+
+{solution}
+
+### Scope
+
+**In Scope:**
+{in_scope}
+
+**Out of Scope:**
+{out_of_scope}
+
+## Context for Development
+
+### Codebase Patterns
+
+{codebase_patterns}
+
+### Files to Reference
+
+| File | Purpose |
+| ---- | ------- |
+
+{files_table}
+
+### Technical Decisions
+
+{technical_decisions}
+
+## Implementation Plan
+
+### Tasks
+
+{tasks}
+
+### Acceptance Criteria
+
+{acceptance_criteria}
+
+## Additional Context
+
+### Dependencies
+
+{dependencies}
+
+### Testing Strategy
+
+{testing_strategy}
+
+### Notes
+
+{notes}

package/_bmad/bmm/workflows/bmad-quick-flow/bmad-quick-spec/workflow.md

@@ -0,0 +1,73 @@
+---
+main_config: '{project-root}/_bmad/bmm/config.yaml'
+
+---
+
+# Quick-Spec Workflow
+
+**Goal:** Create implementation-ready technical specifications through conversational discovery, code investigation, and structured documentation.
+
+**READY FOR DEVELOPMENT STANDARD:**
+
+A specification is considered "Ready for Development" ONLY if it meets the following:
+
+- **Actionable**: Every task has a clear file path and specific action.
+- **Logical**: Tasks are ordered by dependency (lowest level first).
+- **Testable**: All ACs follow Given/When/Then and cover happy path and edge cases.
+- **Complete**: All investigation results from Step 2 are inlined; no placeholders or "TBD".
+- **Self-Contained**: A fresh agent can implement the feature without reading the workflow history.
+
+---
+
+**Your Role:** You are an elite developer and spec engineer. You ask sharp questions, investigate existing code thoroughly, and produce specs that contain ALL context a fresh dev agent needs to implement the feature. No handoffs, no missing context - just complete, actionable specs.
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This uses **step-file architecture** for disciplined execution:
+
+### Core Principles
+
+- **Micro-file Design**: Each step is a self-contained instruction file that must be followed exactly
+- **Just-In-Time Loading**: Only the current step file is in memory - never load future step files until directed
+- **Sequential Enforcement**: Sequence within step files must be completed in order, no skipping or optimization
+- **State Tracking**: Document progress in output file frontmatter using `stepsCompleted` array
+- **Append-Only Building**: Build the tech-spec by updating content as directed
+
+### Step Processing Rules
+
+1. **READ COMPLETELY**: Always read the entire step file before taking any action
+2. **FOLLOW SEQUENCE**: Execute all numbered sections in order, never deviate
+3. **WAIT FOR INPUT**: If a menu is presented, halt and wait for user selection
+4. **CHECK CONTINUATION**: Only proceed to next step when user selects [C] (Continue)
+5. **SAVE STATE**: Update `stepsCompleted` in frontmatter before loading next step
+6. **LOAD NEXT**: When directed, read fully and follow the next step file
+
+### Critical Rules (NO EXCEPTIONS)
+
+- **NEVER** load multiple step files simultaneously
+- **ALWAYS** read entire step file before execution
+- **NEVER** skip steps or optimize the sequence
+- **ALWAYS** update frontmatter of output file when completing a step
+- **ALWAYS** follow the exact instructions in the step file
+- **ALWAYS** halt at menus and wait for user input
+- **NEVER** create mental todo lists from future steps
+
+---
+
+## INITIALIZATION SEQUENCE
+
+### 1. Configuration Loading
+
+Load and read full config from `{main_config}` and resolve:
+
+- `project_name`, `planning_artifacts`, `implementation_artifacts`, `user_name`
+- `communication_language`, `document_output_language`, `user_skill_level`
+- `date` as system-generated current datetime
+- `project_context` = `**/project-context.md` (load if exists)
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### 2. First Step Execution
+
+Read fully and follow: `./steps/step-01-understand.md` to begin the workflow.

package/_bmad/core/config.yaml

@@ -0,0 +1,9 @@
+# CORE Module Configuration
+# Generated by BMAD installer
+# Version: 6.2.0
+# Date: 2026-03-17T01:03:20.533Z
+
+user_name: Jonathan
+communication_language: English
+document_output_language: English
+output_folder: "{project-root}/_bmad-output"

package/_bmad/core/module-help.csv

@@ -0,0 +1,11 @@
+module,phase,name,code,sequence,workflow-file,command,required,agent,options,description,output-location,outputs
+core,anytime,Brainstorming,BSP,,skill:bmad-brainstorming,bmad-brainstorming,false,analyst,,"Generate diverse ideas through interactive techniques. Use early in ideation phase or when stuck generating ideas.",{output_folder}/brainstorming/brainstorming-session-{{date}}.md,,
+core,anytime,Party Mode,PM,,skill:bmad-party-mode,bmad-party-mode,false,party-mode facilitator,,"Orchestrate multi-agent discussions. Use when you need multiple agent perspectives or want agents to collaborate.",,
+core,anytime,bmad-help,BH,,skill:bmad-help,bmad-help,false,,,"Get unstuck by showing what workflow steps come next or answering BMad Method questions.",,
+core,anytime,Index Docs,ID,,skill:bmad-index-docs,bmad-index-docs,false,,,"Create lightweight index for quick LLM scanning. Use when LLM needs to understand available docs without loading everything.",,
+core,anytime,Shard Document,SD,,skill:bmad-shard-doc,bmad-shard-doc,false,,,"Split large documents into smaller files by sections. Use when doc becomes too large (>500 lines) to manage effectively.",,
+core,anytime,Editorial Review - Prose,EP,,skill:bmad-editorial-review-prose,bmad-editorial-review-prose,false,,,"Review prose for clarity, tone, and communication issues. Use after drafting to polish written content.",report located with target document,"three-column markdown table with suggested fixes",
+core,anytime,Editorial Review - Structure,ES,,skill:bmad-editorial-review-structure,bmad-editorial-review-structure,false,,,"Propose cuts, reorganization, and simplification while preserving comprehension. Use when doc produced from multiple subprocesses or needs structural improvement.",report located with target document,
+core,anytime,Adversarial Review (General),AR,,skill:bmad-review-adversarial-general,bmad-review-adversarial-general,false,,,"Review content critically to find issues and weaknesses. Use for quality assurance or before finalizing deliverables. Code Review in other modules run this automatically, but its useful also for document reviews",,
+core,anytime,Edge Case Hunter Review,ECH,,skill:bmad-review-edge-case-hunter,bmad-review-edge-case-hunter,false,,,"Walk every branching path and boundary condition in code, report only unhandled edge cases. Use alongside adversarial review for orthogonal coverage - method-driven not attitude-driven.",,
+core,anytime,Distillator,DG,,skill:bmad-distillator,bmad-distillator,false,,,"Lossless LLM-optimized compression of source documents. Use when you need token-efficient distillates that preserve all information for downstream LLM consumption.",adjacent to source document or specified output_path,distillate markdown file(s)

package/_bmad/core/skills/bmad-advanced-elicitation/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: bmad-advanced-elicitation
+description: 'Push the LLM to reconsider, refine, and improve its recent output.'
+---
+
+Follow the instructions in ./workflow.md.

package/_bmad/core/skills/bmad-advanced-elicitation/bmad-skill-manifest.yaml

@@ -0,0 +1 @@
+type: skill

package/_bmad/core/skills/bmad-advanced-elicitation/methods.csv

@@ -0,0 +1,51 @@
+num,category,method_name,description,output_pattern
+1,collaboration,Stakeholder Round Table,Convene multiple personas to contribute diverse perspectives - essential for requirements gathering and finding balanced solutions across competing interests,perspectives → synthesis → alignment
+2,collaboration,Expert Panel Review,Assemble domain experts for deep specialized analysis - ideal when technical depth and peer review quality are needed,expert views → consensus → recommendations
+3,collaboration,Debate Club Showdown,Two personas argue opposing positions while a moderator scores points - great for exploring controversial decisions and finding middle ground,thesis → antithesis → synthesis
+4,collaboration,User Persona Focus Group,Gather your product's user personas to react to proposals and share frustrations - essential for validating features and discovering unmet needs,reactions → concerns → priorities
+5,collaboration,Time Traveler Council,Past-you and future-you advise present-you on decisions - powerful for gaining perspective on long-term consequences vs short-term pressures,past wisdom → present choice → future impact
+6,collaboration,Cross-Functional War Room,Product manager + engineer + designer tackle a problem together - reveals trade-offs between feasibility desirability and viability,constraints → trade-offs → balanced solution
+7,collaboration,Mentor and Apprentice,Senior expert teaches junior while junior asks naive questions - surfaces hidden assumptions through teaching,explanation → questions → deeper understanding
+8,collaboration,Good Cop Bad Cop,Supportive persona and critical persona alternate - finds both strengths to build on and weaknesses to address,encouragement → criticism → balanced view
+9,collaboration,Improv Yes-And,Multiple personas build on each other's ideas without blocking - generates unexpected creative directions through collaborative building,idea → build → build → surprising result
+10,collaboration,Customer Support Theater,Angry customer and support rep roleplay to find pain points - reveals real user frustrations and service gaps,complaint → investigation → resolution → prevention
+11,advanced,Tree of Thoughts,Explore multiple reasoning paths simultaneously then evaluate and select the best - perfect for complex problems with multiple valid approaches,paths → evaluation → selection
+12,advanced,Graph of Thoughts,Model reasoning as an interconnected network of ideas to reveal hidden relationships - ideal for systems thinking and discovering emergent patterns,nodes → connections → patterns
+13,advanced,Thread of Thought,Maintain coherent reasoning across long contexts by weaving a continuous narrative thread - essential for RAG systems and maintaining consistency,context → thread → synthesis
+14,advanced,Self-Consistency Validation,Generate multiple independent approaches then compare for consistency - crucial for high-stakes decisions where verification matters,approaches → comparison → consensus
+15,advanced,Meta-Prompting Analysis,Step back to analyze the approach structure and methodology itself - valuable for optimizing prompts and improving problem-solving,current → analysis → optimization
+16,advanced,Reasoning via Planning,Build a reasoning tree guided by world models and goal states - excellent for strategic planning and sequential decision-making,model → planning → strategy
+17,competitive,Red Team vs Blue Team,Adversarial attack-defend analysis to find vulnerabilities - critical for security testing and building robust solutions,defense → attack → hardening
+18,competitive,Shark Tank Pitch,Entrepreneur pitches to skeptical investors who poke holes - stress-tests business viability and forces clarity on value proposition,pitch → challenges → refinement
+19,competitive,Code Review Gauntlet,Senior devs with different philosophies review the same code - surfaces style debates and finds consensus on best practices,reviews → debates → standards
+20,technical,Architecture Decision Records,Multiple architect personas propose and debate architectural choices with explicit trade-offs - ensures decisions are well-reasoned and documented,options → trade-offs → decision → rationale
+21,technical,Rubber Duck Debugging Evolved,Explain your code to progressively more technical ducks until you find the bug - forces clarity at multiple abstraction levels,simple → detailed → technical → aha
+22,technical,Algorithm Olympics,Multiple approaches compete on the same problem with benchmarks - finds optimal solution through direct comparison,implementations → benchmarks → winner
+23,technical,Security Audit Personas,Hacker + defender + auditor examine system from different threat models - comprehensive security review from multiple angles,vulnerabilities → defenses → compliance
+24,technical,Performance Profiler Panel,Database expert + frontend specialist + DevOps engineer diagnose slowness - finds bottlenecks across the full stack,symptoms → analysis → optimizations
+25,creative,SCAMPER Method,Apply seven creativity lenses (Substitute/Combine/Adapt/Modify/Put/Eliminate/Reverse) - systematic ideation for product innovation,S→C→A→M→P→E→R
+26,creative,Reverse Engineering,Work backwards from desired outcome to find implementation path - powerful for goal achievement and understanding endpoints,end state → steps backward → path forward
+27,creative,What If Scenarios,Explore alternative realities to understand possibilities and implications - valuable for contingency planning and exploration,scenarios → implications → insights
+28,creative,Random Input Stimulus,Inject unrelated concepts to spark unexpected connections - breaks creative blocks through forced lateral thinking,random word → associations → novel ideas
+29,creative,Exquisite Corpse Brainstorm,Each persona adds to the idea seeing only the previous contribution - generates surprising combinations through constrained collaboration,contribution → handoff → contribution → surprise
+30,creative,Genre Mashup,Combine two unrelated domains to find fresh approaches - innovation through unexpected cross-pollination,domain A + domain B → hybrid insights
+31,research,Literature Review Personas,Optimist researcher + skeptic researcher + synthesizer review sources - balanced assessment of evidence quality,sources → critiques → synthesis
+32,research,Thesis Defense Simulation,Student defends hypothesis against committee with different concerns - stress-tests research methodology and conclusions,thesis → challenges → defense → refinements
+33,research,Comparative Analysis Matrix,Multiple analysts evaluate options against weighted criteria - structured decision-making with explicit scoring,options → criteria → scores → recommendation
+34,risk,Pre-mortem Analysis,Imagine future failure then work backwards to prevent it - powerful technique for risk mitigation before major launches,failure scenario → causes → prevention
+35,risk,Failure Mode Analysis,Systematically explore how each component could fail - critical for reliability engineering and safety-critical systems,components → failures → prevention
+36,risk,Challenge from Critical Perspective,Play devil's advocate to stress-test ideas and find weaknesses - essential for overcoming groupthink,assumptions → challenges → strengthening
+37,risk,Identify Potential Risks,Brainstorm what could go wrong across all categories - fundamental for project planning and deployment preparation,categories → risks → mitigations
+38,risk,Chaos Monkey Scenarios,Deliberately break things to test resilience and recovery - ensures systems handle failures gracefully,break → observe → harden
+39,core,First Principles Analysis,Strip away assumptions to rebuild from fundamental truths - breakthrough technique for innovation and solving impossible problems,assumptions → truths → new approach
+40,core,5 Whys Deep Dive,Repeatedly ask why to drill down to root causes - simple but powerful for understanding failures,why chain → root cause → solution
+41,core,Socratic Questioning,Use targeted questions to reveal hidden assumptions and guide discovery - excellent for teaching and self-discovery,questions → revelations → understanding
+42,core,Critique and Refine,Systematic review to identify strengths and weaknesses then improve - standard quality check for drafts,strengths/weaknesses → improvements → refined
+43,core,Explain Reasoning,Walk through step-by-step thinking to show how conclusions were reached - crucial for transparency,steps → logic → conclusion
+44,core,Expand or Contract for Audience,Dynamically adjust detail level and technical depth for target audience - matches content to reader capabilities,audience → adjustments → refined content
+45,learning,Feynman Technique,Explain complex concepts simply as if teaching a child - the ultimate test of true understanding,complex → simple → gaps → mastery
+46,learning,Active Recall Testing,Test understanding without references to verify true knowledge - essential for identifying gaps,test → gaps → reinforcement
+47,philosophical,Occam's Razor Application,Find the simplest sufficient explanation by eliminating unnecessary complexity - essential for debugging,options → simplification → selection
+48,philosophical,Trolley Problem Variations,Explore ethical trade-offs through moral dilemmas - valuable for understanding values and difficult decisions,dilemma → analysis → decision
+49,retrospective,Hindsight Reflection,Imagine looking back from the future to gain perspective - powerful for project reviews,future view → insights → application
+50,retrospective,Lessons Learned Extraction,Systematically identify key takeaways and actionable improvements - essential for continuous improvement,experience → lessons → actions