majiayu000 This is the F-thread (fusion) pattern: multiple independent analyses converge into one superior answer. Use it when the decision is hard enough that diverse viewpoints add value.
Skip for straightforward implementations, well-established patterns, or decisions where one approach is obviously correct.
Standard perspectives:
- Pragmatist: Simplest solution that works, minimize complexity
- Architect: Long-term maintainability, extensibility, patterns
- Performance: Efficiency, scalability, resource usage
- Security: Attack surface, data protection, access control
- User-focused: UX impact, developer experience, API ergonomics
Domain-specific perspectives (add based on problem):
- Data engineer: For data pipeline decisions
- DevOps: For deployment and infrastructure choices
- Testing: For testability and verification concerns
- Integration: For API and system boundary decisions
Choose perspectives that will genuinely disagree. Similar viewpoints waste the pattern's value. The goal is productive tension that surfaces trade-offs.
Launch agents in parallel using the Task tool. Each agent receives:
- The problem statement
- Their assigned perspective
- Instructions to return: recommended approach, key trade-offs, complexity estimate, risks
Wait for all agents to complete. Agents work independently without seeing each other's responses.
Synthesize by identifying where agents agree (high-confidence elements), where they disagree (trade-off zones), and which perspective's concerns are most relevant given actual constraints.
Produce a unified recommendation that incorporates the strongest elements from multiple approaches while maintaining coherence.
Trade-off resolution: When agents disagree, evaluate based on actual project constraints. The pragmatist might win for a prototype; the architect for a core system.
Risk integration: Incorporate security and performance concerns as constraints on the chosen approach rather than alternative approaches.
Complexity calibration: If most agents flag high complexity, the problem may need decomposition before a single solution emerges.
Recommended Approach: Clear description of the unified solution
Why This Approach: Key factors that made this the best choice
Integrated Trade-offs:
- [Trade-off 1]: How the solution handles it
- [Trade-off 2]: How the solution handles it
Perspectives Incorporated:
- From Pragmatist: [element included]
- From Architect: [element included]
- From Security: [constraint applied]
Complexity: [Low | Medium | High] with brief justification
Dissenting Views: Any perspective whose core concern wasn't fully addressed, and why the trade-off was acceptable
Return a concise recommendation that autotask can incorporate into the plan. The full synthesis rationale goes into the design decisions section of the eventual PR.
Signal when the decision is too close to call - some choices genuinely need human input. Don't force a recommendation when perspectives are evenly split on important factors.
Synthesis beats voting. Don't just pick the most popular approach - integrate the strongest elements from multiple perspectives.
Productive disagreement is the point. When agents agree completely, the problem probably didn't need this pattern.
Know when to escalate. Some decisions genuinely need human judgment. Synthesize what you can, flag what you can't.