Sacco research to plan

Research-to-Plan Pipeline

Transforms a research question into an actionable, phased implementation plan with full traceability from research findings to requirements to architecture to phases.

When to Use

• Starting a new project or major feature
• Technology selection (choosing frameworks, crates, services)
• Exploring a domain (e.g. a new data platform, ML architectures, etc.)
• User asks to "research and plan" something
• User says "figure out the best way to..."

Pipeline Stages

Stage 1: Research Dispatch

Use a deep-research tool/skill to launch multi-source research, if available. Otherwise dispatch 3-5 parallel research agents, each focused on a different facet:

Agent 1: State-of-the-art in <domain> (academic + industry)
Agent 2: Existing tools/libraries/services that solve this
Agent 3: Architecture patterns and best practices
Agent 4: Case studies and production deployments
Agent 5: Cost/performance/trade-off analysis

Output: docs/research/<topic>-research.md with source citations

Stage 2: Requirements Extraction

From research findings, produce a requirements table:

# Requirements: <feature/system>

| Ref | Category | Requirement | Priority | Source | Notes |
|-----|----------|------------|----------|--------|-------|
| R-001 | Core | Must support graph traversal with 1M+ nodes | Must | research-agent-3 | Comparable systems handle 10M+ |
| R-002 | Core | Real-time incremental updates | Must | research-agent-1 | Streaming-update pattern |
| R-003 | UX | Canvas-based node interaction | Should | research-agent-4 | Node-link diagram UX |
| R-004 | Ops | Horizontal scalability | Could | research-agent-5 | Only if >100 concurrent users |

Categories: Core, UX, Data, Security, Ops, Integration Priorities: Must (MVP), Should (v1.1), Could (backlog), Won't (explicit exclusion)

Output: docs/plans/<topic>-requirements.md

Stage 3: Architecture Derivation

From requirements, derive the architecture:

1. Component map: What components are needed to satisfy each requirement
2. Technology selection: For each component, which library/framework/service
   • Must justify: why this over alternatives?
   • Must cite: what research finding supports this choice?
3. Data flow: How data moves between components
4. API contracts: Key interfaces between components
5. Non-functional requirements: Performance targets, scaling strategy

Output: docs/plans/<topic>-architecture.md

Stage 4: Phased Plan

Break the architecture into phases for sacco-phased-execution:

# Implementation Plan: <feature/system>

## Phase 0: Foundation
- **Deliverables:** Project scaffold, CI, basic types
- **Requirements covered:** (none — infrastructure only)
- **Estimated tests:** 20-30
- **Dependencies:** none

## Phase 1: <core-capability>
- **Deliverables:** <specific components>
- **Requirements covered:** R-001, R-002
- **Estimated tests:** 50-80
- **Dependencies:** Phase 0

## Phase 2: <next-capability>
...

Rules for phasing:

• Each phase must be independently testable and committable
• Must requirements come first (Phases 0-N), Should requirements after, Could last
• Each phase lists which requirements it satisfies (traceability)
• Phase 0 is always foundation/scaffold

Output: docs/plans/<topic>-plan.md

Stage 5: Handoff

Present the complete pipeline output to the user:

1. Research summary (key findings, not the full report)
2. Requirements table
3. Architecture overview
4. Phased plan

Wait for user approval before execution. The plan feeds directly into sacco-phased-execution.

Rules

• Research MUST happen before requirements. No inventing requirements from assumptions.
• Every requirement must trace to a research finding or explicit user input.
• Every architecture decision must trace to a requirement.
• Every phase must trace to requirements it covers.
• If research reveals the problem is already solved (existing tool/library), recommend that instead of building.
• The plan must include explicit "Won't" items to prevent scope creep.

Integration

• A deep-research tool (if available): Source dispatch in Stage 1
• sacco-phased-execution: Plan handoff in Stage 5
• sacco-codebase-audit: Can audit the plan before execution begins
• sacco-architecture-evaluation: Can be used in Stage 3 for architecture decisions
• Research-before-building: This skill is how you avoid solving already-solved problems