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:

• Analyze PRD Structure - Identify features, tech requirements, implicit dependencies

• Map Dependencies - What depends on what? Shared infrastructure needs?

• Define Task Boundaries - Atomic, single responsibility, independently testable

• Generate Implementation Details - Pseudo-code, file structures, library versions

• Define Test Strategies - Acceptance criteria, unit/integration/E2E guidance

• 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:

Service Name Agent Tech Stack Description

Notification Router rex Rust/Axum High-performance API

Integration Service nova Bun/Elysia/Effect Channel delivery

Admin API grizz Go/gRPC Tenant management

Web Console blaze Next.js/React/shadcn Admin dashboard

Mobile App tap Expo/React Native Mobile client

Desktop Client spark Electron Desktop notifications

Agent Assignment Rules

Implementation Agents (Write Code)

Agent Language/Stack Use For

bolt Kubernetes/Helm Infrastructure (Task 1 ONLY)

rex Rust/Axum/Tokio Rust backend services

grizz Go/gRPC/Chi Go backend services

nova Bun/Elysia/Effect TypeScript backend

blaze Next.js/React/shadcn Web frontends

tap Expo/React Native Mobile apps

spark Electron Desktop apps

Support Agents (Review Only - AFTER Implementation)

Agent Role Use ONLY For

cleo Quality Review Code review AFTER PR

cipher Security Audit Security audit AFTER PR

tess Testing Writing tests AFTER PR

atlas Integration Merging PRs AFTER reviews

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)