backlog

Generate prioritized product backlog from requirements with sprint planning

Product Backlog Generation

Generate prioritized product backlog from ArcKit artifacts, converting requirements to user stories with sprint planning.

Command

arckit backlog [OPTIONS]

Description

Automatically converts your requirements into a prioritized product backlog with GDS-compliant user stories, epics, and sprint plans. Uses multi-factor prioritization and dependency analysis.

Arguments

SPRINT_LENGTH: Sprint duration (default: 2w)

• Valid: 1w, 2w, 3w, 4w

SPRINTS: Number of sprints to plan (default: 8)

VELOCITY: Team velocity in story points (default: 20)

FORMAT: Output formats (default: markdown)

• Valid: markdown, csv, json, all

PRIORITY: Prioritization approach (default: multi)

• moscow - MoSCoW only
• risk - Risk-based only
• value - Value-based only
• dependency - Dependency-based only
• multi - Multi-factor (recommended)

When to Use

• After requirements definition
• Before sprint planning
• When starting implementation
• For backlog refinement
• To export to Jira/Azure DevOps

Required Context

• Requirements (ARC--REQ-.md) - MANDATORY
• Stakeholder Analysis (ARC--STKE-.md) - For personas
• Risk Register (ARC--RISK-.md) - For risk priorities
• Business Case (ARC--SOBC-.md) - For value priorities
• HLD/DLD - For component mapping

Features

1. Requirements to Stories

Conversion mapping:

• BR-xxx → Epics
• FR-xxx → User Stories (GDS format)
• NFR-xxx → Technical Tasks
• INT-xxx → Integration Stories
• DR-xxx → Data Tasks

2. GDS-Compliant User Stories

As a [persona]
I want [capability]
So that [goal]

Acceptance Criteria:
- It's done when [measurable outcome 1]
- It's done when [measurable outcome 2]

3. Multi-Factor Prioritization

Priority Score = ( MoSCoW_Weight × 40% + Risk_Weight × 20% + Value_Weight × 20% + Dependency_Weight × 20% )

Weights:

• Must Have = 4, Should Have = 3, Could Have = 2
• Critical risk = 4, High = 3, Medium = 2, Low = 1
• High ROI = 4, Medium = 3, Low = 2
• Blocks many (>5) = 4, Some (3-5) = 3, Few (1-2) = 2

4. Sprint Planning

Sprint 1 - Foundation:

• User authentication
• Database setup
• CI/CD pipeline
• Testing framework
• Basic security

Subsequent Sprints:

• 60% Feature stories
• 20% Technical tasks
• 15% Testing tasks
• 5% Bug buffer

5. Story Point Estimation

Fibonacci sequence: 1, 2, 3, 5, 8, 13

Guidelines:

• 1 point: Trivial (<2 hours)
• 2 points: Simple (half day)
• 3 points: Moderate (1 day)
• 5 points: Complex (2-3 days)
• 8 points: Very complex (1 week)
• 13 points: Too large (break down)

Factors increasing points:

• Multiple components (+2)
• Security requirements (+2)
• External integration (+2)
• Data migration (+2)
• Complex validation (+1)
• Performance requirements (+2)
• Compliance (+1)

6. Dependency Management

Foundation first:

• Auth before features
• Database before data operations
• CI/CD before deployments

Integration before features:

• Stripe API before payment UI
• Email service before notifications

Parent before child:

• “Create account” before “Update profile”

Output Files

Markdown Report

projects/{project}/ARC-{PROJECT_ID}-BKLG-v1.0.md

Contains:

• Executive summary
• Epic definitions
• Prioritized backlog
• Sprint plans (8 sprints)
• Traceability matrix
• Dependency graphs (Mermaid)
• Definition of Done

CSV Export

projects/{project}/ARC-{PROJECT_ID}-BKLG-v1.0.csv

For import to:

• Jira
• Azure DevOps
• GitHub Projects

Columns:

• Type, Key, Epic, Summary, Description
• Acceptance Criteria, Priority, Story Points
• Sprint, Status, Component, Requirements

JSON Export

projects/{project}/ARC-{PROJECT_ID}-BKLG-v1.0.json

For programmatic access:

• Complete backlog structure
• Epics, stories, tasks
• Sprint assignments
• Traceability links

Example Usage

Basic

arckit backlog

Generates 8 sprints at 20 points/sprint using multi-factor priority.

Custom Velocity

arckit backlog VELOCITY=25 SPRINTS=12

Generates 12 sprints at 25 points/sprint.

Export All Formats

arckit backlog FORMAT=all

Generates markdown + CSV + JSON.

Risk-Based Only

arckit backlog PRIORITY=risk

Prioritizes solely by risk level.

Interactive Configuration

If not specified via arguments, prompts for:

1. Priority approach:

   • Multi-factor (Recommended)
   • MoSCoW
   • Value vs Effort
   • Risk-based

2. Output format:

   • All formats (Recommended)
   • Markdown only
   • CSV only
   • JSON only

Backlog Contents

Epic Structure

## Epic 1: User Management (BR-001)

**Priority**: Must Have
**Business Value**: High - Foundation for features
**Total Story Points**: 34
**Estimated Duration**: 2 sprints

**Stories**:
1. Story-001: Create user account (8 points)
2. Story-002: User login (5 points)
...

Story Structure

### Story-001: Create user account

**As a** new user
**I want** to create an account
**So that** I can access the service

**Acceptance Criteria**:
- It's done when email verification sent
- It's done when account created after verification
- It's done when GDPR consent captured

**Technical Tasks**:
- Task-001-A: Design user table (2 points)
- Task-001-B: Implement registration API (3 points)
- Task-001-C: Email verification service (3 points)

**Requirements**: FR-001, NFR-008, NFR-012
**Component**: User Service
**Story Points**: 8
**Priority**: Must Have
**Sprint**: 1

Time Savings

Manual backlog creation:

• Convert requirements: 2-3 weeks
• Prioritize and sequence: 1 week
• Sprint planning: 1 week
• Total: 4-6 weeks (80-120 hours)

With arckit backlog:

• Run command: 2-5 minutes
• Review and refine: 1-2 days
• Team refinement: 2-3 days
• Total: 3-5 days (24-40 hours)

Time savings: 75-85%

Related Commands

• arckit trello - Export backlog to Trello board
• arckit traceability - Map stories to requirements
• arckit requirements - Source requirements

Next Steps

After generating backlog:

1. Review with your team
2. Refine acceptance criteria and points
3. Validate dependencies and priorities
4. Begin sprint planning for Sprint 1
5. Track actual velocity and adjust
6. Run arckit trello to create Trello board

Important Notes

Story Point Accuracy

AI-generated points are estimates. Teams should:

• Re-estimate based on velocity
• Use team poker for consensus
• Track actual vs estimated
• Adjust future estimates

Velocity Calibration

After Sprint 1:

1. Calculate actual velocity (sum of Done points)
2. Adjust Sprint 2+ capacity
3. Track velocity trend
4. Account for team changes

Backlog Grooming

• Weekly: Refine next 2 sprints
• Bi-weekly: Groom backlog beyond 2 sprints
• Monthly: Review epic priorities
• Per sprint: Update based on completed work