PRD Analysis and Task Decomposition

Patterns for parsing PRDs and generating comprehensive task documentation.

Critical Success Criteria

Output quality is measured by how well agents can implement tasks WITHOUT needing to re-read the PRD. Each task must be self-contained with all necessary context embedded.

Structured Analysis (Chain of Thought)

Before generating tasks, think step-by-step:

1. Analyze PRD Structure – Identify features, tech requirements, implicit dependencies
2. Map Dependencies – What depends on what? Shared infrastructure needs?
3. Define Task Boundaries – Atomic, single responsibility, independently testable
4. Generate Implementation Details – Pseudo-code, file structures, library versions
5. Define Test Strategies – Acceptance criteria, unit/integration/E2E guidance
6. Self-Verify – All requirements covered? No circular deps? Valid ordering?

Service Discovery

Before generating any tasks, analyze the PRD to identify all services and their tech stacks.

Create a Service-to-Agent Mapping Table:

Agent Assignment Rules

Implementation Agents (Write Code)

Support Agents (Review Only – AFTER Implementation)

CRITICAL: Support agents are NEVER assigned to implementation tasks.

Task 1: Always Infrastructure

Task 1 must ALWAYS be assigned to Bolt to provision:

• Databases (PostgreSQL, MongoDB)
• Caches (Redis/Valkey)
• Message queues (Kafka, NATS)
• Object storage (SeaweedFS S3)

Code Signatures in Details

Include language-specific function/struct signatures in task details:

Rust Example

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Notification {
    pub id: Uuid,
    pub tenant_id: Uuid,
    pub channel: Channel,
}

pub async fn create_notification(
    State(state): State<AppState>,
    Json(req): Json<CreateNotificationRequest>,
) -> Result<Json<NotificationResponse>, ApiError>

TypeScript/Effect Example

import { Schema } from "@effect/schema"
import { Effect } from "effect"

export const Integration = Schema.Struct({
  id: Schema.UUID,
  name: Schema.String,
  channel: Schema.Literal("slack", "discord", "email"),
})

Go Example

type TenantServiceServer struct {
    pb.UnimplementedTenantServiceServer
    db *pgxpool.Pool
}

func (s *TenantServiceServer) CreateTenant(
    ctx context.Context,
    req *pb.CreateTenantRequest,
) (*pb.Tenant, error)

Task JSON Format

{
  "tasks": [
    {
      "id": "1",
      "title": "Provision Infrastructure",
      "description": "Deploy PostgreSQL, Redis, Kafka clusters",
      "priority": "critical",
      "status": "pending",
      "dependencies": [],
      "agentHint": "bolt",
      "details": "Full implementation details with code signatures",
      "testStrategy": "Verification commands and expected outputs"
    }
  ]
}

Quality Checklist

Before finalizing:

• Service table created with all services from PRD
• Task 1 is agentHint: "bolt" for infrastructure
• Every task has agentHint set
• Implementation agents only for code tasks
• Support agents ONLY for review/audit tasks
• Code signatures in details for all implementation tasks
• No auth/jwt/oauth tasks assigned to cipher
• Dependencies form valid DAG (no cycles)
• Implementation tasks depend on task-1
• Each task is atomic (completable in one PR)