Common Workflows

Real-world patterns and best practices for task management with AI agents

Production-Tested Workflows

These workflows are used by 500+ development teams managing 50,000+ tasks per month with AI agents.

What you’ll learn:

• 8 battle-tested workflow patterns
• Real-world examples with actual numbers
• Common pitfalls and how to avoid them
• Team coordination strategies

---

Workflow 1: Daily Development Cycle

Use case: Solo developer with 1 AI assistant

Time: 15 seconds per day

Morning Routine

Start your work session (1 command):

You: "Start task session"

Claude: "# Task Session Started

         Agent: claude-desktop-main
         Project: backend-api

         ## Your Statistics
         Total Assigned: 12 tasks
         - Todo: 5
         - In Progress: 2
         - In Review: 1
         - Completed: 4 (this week)

         Overdue: 0 ✅
         Critical Priority: 1 🔥

         ## Your Active Tasks (8)

         ### [CRITICAL] BACKEND-042: Fix auth timeout
         Due: Today at 5 PM (7 hours remaining)
         Estimate: 2 hours

         ### [HIGH] BACKEND-045: Add rate limiting
         Due: Tomorrow
         Estimate: 4 hours

         ### [MEDIUM] BACKEND-050: Refactor controller
         No due date
         Estimate: 3 hours

         Recommended: Start with BACKEND-042 (critical, due today)"

What you get:

• ✅ Instant overview of all your work
• ✅ Highlights urgent tasks (overdue, critical, due today)
• ✅ Recommended task to start with
• ✅ Zero manual tracking needed

Time saved: 5 minutes per day

(No need to check dashboard, filter tasks, calculate priorities manually)

During the Day

Update task status as you work:

# Starting work
You: "Start BACKEND-042"
Claude: *marks as in_progress*
        "Started BACKEND-042 at 10:23 AM"

# Taking a break / switching tasks
You: "I need to context switch to BACKEND-050"
Claude: "BACKEND-042 is still in progress.
         Should I mark it as blocked or leave it in progress?"

# Completing work
You: "Done with BACKEND-042, mark for review"
Claude: *marks as in_review*
        "BACKEND-042 ready for review.
         Worked for 1.8 hours (estimate was 2h) ✅"

# After review
You: "Review passed, mark BACKEND-042 complete"
Claude: *marks as completed*
        "BACKEND-042 completed!
         Total time: 1.8 hours
         Completed 0.2 hours under estimate"

Benefits:

• ✅ Accurate time tracking (started_at, completed_at automatic)
• ✅ Historical data for future estimates
• ✅ Context switching tracked (useful for retrospectives)

End of Day

Review your progress:

You: "What did I accomplish today?"

Claude: "# Daily Summary (2025-01-12)

         ## Completed Tasks (3)
         ✅ BACKEND-042: Fix auth timeout (1.8h)
         ✅ BACKEND-045: Add rate limiting (3.2h)
         ✅ BACKEND-048: Update docs (0.5h)

         Total: 5.5 hours of focused work

         ## Still In Progress (2)
         🔄 BACKEND-050: Refactor controller (2.1h so far)
         🔄 BACKEND-052: Add logging (0.3h so far)

         ## Productivity Metrics
         Tasks completed: 3
         Avg completion time: 1.8 hours
         Estimate accuracy: 95% (very good!)

         ## Tomorrow's Priority
         🔥 BACKEND-050 (in progress, almost done)
         📋 BACKEND-055 (high priority, due in 2 days)

         Great job today! 🎉"

Why it matters:

• ✅ Sense of accomplishment (see what you shipped)
• ✅ Identify blockers (tasks taking too long)
• ✅ Improve estimates (learn from actual times)
• ✅ Plan tomorrow (know what to start with)

---

Workflow 2: Feature Development (Multi-Agent)

Use case: 3 developers with AI assistants building a feature

Team: Backend dev (Claude), Frontend dev (Cursor), QA (Windsurf)

Timeline: 1 week feature delivery

Day 1: Planning

Backend dev creates feature breakdown:

You: "Create tasks for OAuth2 feature:

      Backend (me):
      1. Add OAuth database tables (2h)
      2. Implement OAuth endpoints (4h)
      3. Add token refresh logic (3h)

      Frontend (Cursor):
      4. OAuth login button UI (2h)
      5. Handle OAuth callback (3h)
      6. Add OAuth profile display (2h)

      QA (Windsurf):
      7. OAuth integration tests (4h)
      8. E2E OAuth flow test (3h)

      Set up dependencies automatically."

Claude: "Creating 8 tasks with dependency chain...

         ✅ Created 8 tasks:

         Backend (Claude):
         BACKEND-070: OAuth database tables
         BACKEND-071: OAuth endpoints (depends on BACKEND-070)
         BACKEND-072: Token refresh (depends on BACKEND-071)

         Frontend (Cursor):
         FRONTEND-080: Login button (depends on BACKEND-071)
         FRONTEND-081: OAuth callback (depends on FRONTEND-080)
         FRONTEND-082: Profile display (depends on FRONTEND-081)

         QA (Windsurf):
         TEST-050: Integration tests (depends on BACKEND-072)
         TEST-051: E2E tests (depends on FRONTEND-082, TEST-050)

         Auto-assigned based on team member mentioned
         Dependencies prevent blocking work

         Total estimate: 23 hours across team
         Timeline: 5 days (with parallelization)

         Ready to start!"

Planning time: 2 minutes

Traditional planning: 30 minutes (meeting, discussion, Jira tickets)

Time saved: 28 minutes

Day 2-3: Backend Work

Claude (backend dev) executes:

Day 2:
09:00 - Start BACKEND-070 (database tables)
11:00 - Complete BACKEND-070
        → BACKEND-071 automatically unblocked

11:30 - Start BACKEND-071 (endpoints)
16:00 - Complete BACKEND-071
        → BACKEND-072 unblocked
        → FRONTEND-080 unblocked (Cursor can start UI)

Day 3:
09:00 - Start BACKEND-072 (token refresh)
12:00 - Complete BACKEND-072
        → TEST-050 unblocked (Windsurf can test)

What Cursor sees (Day 3, 11am):

Cursor: "Start task session"

Response: "Agent: cursor-main

           Your Tasks:
           ✅ Available: FRONTEND-080 (Login button)
              Dependencies completed ✅
              Ready to start

           ⏳ Blocked: FRONTEND-081 (OAuth callback)
              Waiting for: FRONTEND-080
           ⏳ Blocked: FRONTEND-082 (Profile display)
              Waiting for: FRONTEND-081

           Recommendation: Start FRONTEND-080 now"

Coordination benefit:

• ✅ Zero meetings to coordinate
• ✅ Real-time visibility into backend progress
• ✅ Automatic unblocking (no manual notifications)
• ✅ No wasted time (Cursor knows exactly when to start)

Day 4-5: Parallel Work

Day 4: Claude + Cursor work in parallel:

Claude (Backend):
09:00 - BACKEND-072 in progress (token refresh)

Cursor (Frontend):
09:00 - FRONTEND-080 completed
10:00 - FRONTEND-081 in progress (callback handling)

[No conflicts - different files, coordinated via tasks]

Day 5: QA begins testing:

Windsurf: "Start task session"

Response: "Agent: windsurf-main

           Your Tasks:
           ✅ Available: TEST-050 (Integration tests)
              All dependencies completed ✅

           ⏳ Blocked: TEST-051 (E2E tests)
              Waiting for: FRONTEND-082
              ETA: 2 hours

           Recommendation: Start TEST-050,
                          TEST-051 will be ready this afternoon"

Windsurf starts TEST-050 at 10am
Cursor completes FRONTEND-082 at 2pm
→ TEST-051 automatically unblocked
Windsurf starts TEST-051 at 2:30pm

Results

Feature delivered in 5 days:

Team Performance:

Claude (Backend):
- 3 tasks completed
- 9 hours total (estimate: 9 hours)
- Accuracy: 100%

Cursor (Frontend):
- 3 tasks completed
- 7.5 hours total (estimate: 7 hours)
- Accuracy: 107% (slightly over)

Windsurf (QA):
- 2 tasks completed
- 6.8 hours total (estimate: 7 hours)
- Accuracy: 97%

Overall:
✅ Feature completed: 5 days (on time)
✅ Zero merge conflicts
✅ Zero coordination meetings
✅ 100% test coverage

Coordination overhead: 15 minutes total
(vs. 3 hours in traditional workflow)

Time saved: 2.75 hours (165 minutes)

ROI:

3 developers × 2.75 hours saved = 8.25 hours

At $100/hour = **$825 saved** on one feature

ULPI Tasks Pro: $29/month

ROI: 2,845%

---

Workflow 3: Bug Fix Sprint

Use case: Fix 50 production bugs in 48 hours

Team: 5 developers with AI assistants

Hour 0: Triage

Import bugs from monitoring tool:

Lead dev: "Import 50 bugs from Sentry,
           auto-prioritize by user impact"

Claude: "Importing 50 bugs...

         ✅ Created 50 bug tasks

         Priority distribution:
         - Critical (500+ users): 5 bugs
         - High (100+ users): 15 bugs
         - Medium (10-100 users): 20 bugs
         - Low (<10 users): 10 bugs

         Auto-tagged by category:
         #backend: 28 bugs
         #frontend: 15 bugs
         #database: 7 bugs

         Estimated total effort: 87 hours
         With 5 devs: ~17 hours each
         Timeline: 2 days (with buffer)

         Ready for team to claim work"

Time: 3 minutes to triage 50 bugs

Hour 1: Team Claims Work

Each dev claims bugs in their specialty:

Dev 1 (Backend specialist):
"Claim critical backend bugs"
→ Claims 3 critical + 5 high priority = 8 bugs (14 hours)

Dev 2 (Frontend specialist):
"Claim critical frontend bugs"
→ Claims 2 critical + 6 high priority = 8 bugs (13 hours)

Dev 3 (Database specialist):
"Claim all database bugs"
→ Claims 7 database bugs (12 hours)

Dev 4 (Full-stack):
"Claim high priority bugs, any category"
→ Claims 4 high + 6 medium = 10 bugs (16 hours)

Dev 5 (Full-stack):
"Claim remaining high priority bugs"
→ Claims 8 bugs (15 hours)

---

Total claimed: 41/50 bugs (82%)
Unclaimed: 9 low priority bugs
(Will be claimed as devs finish current work)

Hour 2-48: Execution

Real-time progress tracking:

After 4 hours:
You: "Show bug fix progress"

Claude: "Bug Fix Sprint Status:

         Critical (5 bugs):
         ✅ Fixed: 3 (60%)
         🔄 In Progress: 2 (40%)
         ETA: 2 hours

         High Priority (15 bugs):
         ✅ Fixed: 6 (40%)
         🔄 In Progress: 7 (47%)
         📋 Todo: 2 (13%)
         ETA: 8 hours

         Medium Priority (20 bugs):
         ✅ Fixed: 2 (10%)
         🔄 In Progress: 8 (40%)
         📋 Todo: 10 (50%)

         Low Priority (10 bugs):
         📋 Todo: 10 (100%)

         Team Velocity:
         Bugs fixed: 11 bugs in 4 hours
         Avg time per bug: 1.8 hours
         Current rate: 2.75 bugs/hour

         Projected completion:
         All critical + high: 10 hours (on track ✅)
         All bugs: 32 hours (16 hours ahead of estimate)"

After 24 hours:

Bug Fix Sprint Status:

✅ Critical: 5/5 (100%) - ALL FIXED
✅ High: 15/15 (100%) - ALL FIXED
🔄 Medium: 18/20 (90%)
📋 Low: 3/10 (30%)

Team Performance:
- 38 bugs fixed in 24 hours
- Avg 1.9 hours per bug
- 12 bugs remaining (all medium/low)
- ETA for all bugs: 6 hours

On track to finish 6 hours early ✅

Results (48 hours)

Final metrics:

Bug Fix Sprint Complete:

Bugs fixed: 50/50 (100%)
Time taken: 42 hours (6 hours under estimate)

By Priority:
✅ Critical: 5/5 (fixed in 6 hours)
✅ High: 15/15 (fixed in 18 hours)
✅ Medium: 20/20 (fixed in 32 hours)
✅ Low: 10/10 (fixed in 42 hours)

Team Performance:
Dev 1: 9 bugs (15.2 hours, 1.7h avg)
Dev 2: 11 bugs (18.4 hours, 1.7h avg)
Dev 3: 8 bugs (14.1 hours, 1.8h avg)
Dev 4: 12 bugs (21.3 hours, 1.8h avg)
Dev 5: 10 bugs (18.0 hours, 1.8h avg)

Coordination overhead:
- Triage: 3 minutes
- Claiming work: 10 minutes
- Progress tracking: 5 min/day = 10 min
- Total: 23 minutes

Traditional bug fix sprint overhead:
- Triage meeting: 60 minutes
- Daily standups: 30 min/day = 60 min
- Coordination: 20 min/day = 40 min
- Total: 160 minutes

Time saved: 137 minutes (2.3 hours)

---

Workflow 4: Release Preparation

Use case: Prepare for production release (checklist completion)

Week Before Release

Create release checklist:

You: "Create release checklist for v2.0 launch:

      Code Quality:
      - All tests passing
      - No critical bugs
      - Code review completed
      - Performance benchmarks pass

      Documentation:
      - API docs updated
      - Changelog written
      - Migration guide created
      - Release notes drafted

      Infrastructure:
      - Production deploy tested
      - Database migrations ready
      - Monitoring dashboards updated
      - Rollback plan documented

      Communication:
      - Blog post written
      - Email to customers scheduled
      - Social media posts ready
      - Support team trained"

Claude: "Creating 16 release tasks...

         ✅ Created 16 tasks tagged #release-v2.0

         By category:
         - Code Quality: 4 tasks (8 hours)
         - Documentation: 4 tasks (6 hours)
         - Infrastructure: 4 tasks (10 hours)
         - Communication: 4 tasks (5 hours)

         Total: 29 hours
         Timeline: 5 days before release

         Dependencies set:
         - Communication depends on Documentation
         - Infrastructure depends on Code Quality

         Auto-assigned to team based on expertise"

Daily Progress

Track release readiness:

You: "Show release readiness for v2.0"

Claude: "Release v2.0 Readiness:

         Overall: 75% complete (12/16 tasks)

         ✅ Code Quality: 4/4 (100%)
         ✅ Documentation: 4/4 (100%)
         🔄 Infrastructure: 3/4 (75%)
            ⏳ Monitoring dashboards (in progress)
         🔄 Communication: 1/4 (25%)
            📋 Blog post (todo)
            📋 Email to customers (blocked: waiting for blog post)
            📋 Social media (blocked: waiting for blog post)

         Blockers:
         - Infrastructure: Monitoring dashboards taking longer than expected
           (4h estimate, 6h actual so far)
         - Communication: Waiting for blog post to finalize messaging

         Risk Assessment:
         🟢 Low risk - 4 tasks remaining
         🟢 All blockers have clear owners
         🟢 2 days buffer before release

         Recommended action:
         1. Prioritize monitoring dashboards (almost done)
         2. Start blog post draft (unblocks 2 other tasks)

         ETA: All tasks complete in 8 hours
         Release: On track for Friday ✅"

Release Day

Final check:

You: "Is v2.0 ready to release?"

Claude: "✅ v2.0 Release Checklist: 100% COMPLETE

         Code Quality: ✅ All 4 tasks complete
         - Tests passing (100% coverage)
         - Zero critical bugs
         - Code review done
         - Performance benchmarks: PASS

         Documentation: ✅ All 4 tasks complete
         - API docs updated
         - Changelog published
         - Migration guide live
         - Release notes reviewed

         Infrastructure: ✅ All 4 tasks complete
         - Production deploy tested
         - Database migrations ready
         - Monitoring dashboards live
         - Rollback plan documented

         Communication: ✅ All 4 tasks complete
         - Blog post published
         - Customer email scheduled (10 AM)
         - Social media queued
         - Support team trained

         🚀 READY FOR RELEASE

         All 16 tasks completed
         No blockers
         No critical issues

         Green light for v2.0 launch ✅"

Release confidence: 100% (all tasks verified)

---

Workflow 5: Onboarding New AI Agent

Use case: Add a new AI assistant to existing team

Setup (2 minutes)

New agent joins project:

New agent: "Start task session for project backend-api"

Claude (ULPI): "Welcome! Registering you as a new agent...

                 ✅ Registered: cursor-agent-2
                 Project: backend-api
                 Capabilities: [auto-detected from your profile]
                   - TypeScript
                   - Frontend development
                   - React

                 Current team (3 agents):
                 - claude-main (backend, 12 tasks)
                 - cursor-main (frontend, 8 tasks)
                 - cursor-agent-2 (you, 0 tasks)

                 Available tasks for you:
                 Found 15 frontend tasks available

                 Would you like to claim some work?"

Auto-registration benefits:

• ✅ Zero manual setup (agent registers itself)
• ✅ Capability detection (based on agent type)
• ✅ Immediate work assignment (can claim tasks right away)

First Tasks

Agent claims work:

Cursor-agent-2: "Claim 3 frontend tasks, medium priority"

Claude: "Searching for frontend tasks...

         Perfect matches for you:
         1. FRONTEND-090: Refactor button component (2h, medium)
         2. FRONTEND-092: Add loading states (3h, medium)
         3. FRONTEND-095: Fix mobile layout (2h, medium)

         ✅ Claimed 3 tasks
         Estimated workload: 7 hours

         These tasks are independent (no dependencies)
         You can start any of them right away

         Recommendation: Start with FRONTEND-090 (smallest, good intro task)"

Team Visibility

Other agents see new team member:

Claude-main: "Who's working on frontend right now?"

Claude: "Frontend team:

         cursor-main:
         - 8 tasks assigned (6 in progress, 2 todo)
         - Working on: FRONTEND-087 (dashboard redesign)

         cursor-agent-2: [NEW TEAM MEMBER]
         - 3 tasks assigned (1 in progress, 2 todo)
         - Working on: FRONTEND-090 (button refactor)

         Frontend backlog:
         - 12 tasks remaining (unassigned)
         - Estimate: 24 hours

         Team capacity:
         Current: 16 hours/week (2 agents)
         Recommended: Claim more tasks for cursor-agent-2"

Coordination:

• ✅ Instant visibility (no announcement needed)
• ✅ Work distribution (team sees who’s doing what)
• ✅ Capacity planning (suggests balancing workload)

---

Best Practices

1. Start Every Session with 'Start Task Session'

Why:

• Get instant overview of your work
• See what’s urgent (overdue, critical, due today)
• Auto-register if first time

Time: 1 second

Saves: 5 minutes of manual checking

2. Use Bulk Operations for Planning

Why:

• Create 50+ tasks in seconds
• Auto-infer dependencies
• Consistent formatting

Example:

"Create 30 tasks for refactoring project"

Time: 2 seconds

Saves: 20 minutes of manual task creation

3. Let Dependencies Prevent Blocking

Why:

• Agents can’t start work that will be blocked
• Automatic unblocking when dependencies complete
• Zero coordination overhead

Example:

Frontend task depends on Backend API
→ Frontend agent can't start until API is done
→ Automatically unblocked when API completes

4. Track Time to Improve Estimates

Why:

• Learn how long tasks actually take
• Improve future estimates
• Identify bottlenecks

ULPI tracks automatically:

• started_at (when status → in_progress)
• completed_at (when status → completed)
• Actual hours vs. estimate

5. Use Tags for Filtering

Why:

• Group related tasks
• Easy filtering later
• Better reporting

Example:

Tags: ["backend", "api", "oauth", "sprint-12"]

Later: "Show all sprint-12 tasks"
→ Filters to just that sprint

6. Claim Work Based on Capacity

Why:

• Prevent overload
• Balance work across team
• Realistic timelines

Example:

"Claim 5 tasks (10 hours total)"
→ Realistic for 2-day sprint

Avoid:

Claiming 20 tasks (40 hours)
→ Will take 5 days, unrealistic for 2-day sprint

---

Anti-Patterns (What NOT to Do)

❌ Creating Tasks Without Dependencies

Bad:

BACKEND-070: Database schema
BACKEND-071: API endpoints
FRONTEND-080: UI component

[No dependencies set]

Problem:

• Frontend agent starts UI before API is ready
• Merge conflict when both edit same files
• Wasted work that needs redoing

Good:

BACKEND-070: Database schema
BACKEND-071: API endpoints (depends on BACKEND-070)
FRONTEND-080: UI component (depends on BACKEND-071)

→ Frontend can't start until API is done ✅

❌ Vague Task Titles

Bad:

BACKEND-001: Fix bug
BACKEND-002: Update code
BACKEND-003: Make changes

Problem:

• Can’t search for tasks later
• Don’t know what was done
• No context for other agents

Good:

BUG-001: Fix authentication timeout in OAuth flow
IMPROVE-002: Optimize database query in user search (reduce from 2s to 200ms)
REFACTOR-003: Extract duplicate validation logic into shared utility

❌ Not Using Bulk Operations

Bad:

"Create task 1: Add database table"
"Create task 2: Add API endpoint"
"Create task 3: Add frontend UI"
... [47 more times for 50 tasks]

Time: 25 minutes

Problem:

• Tedious and error-prone
• Inconsistent formatting
• Miss dependencies

Good:

"Create 50 tasks from this list:
 [paste all 50 tasks]

 Auto-infer dependencies"

Time: 2 minutes

Saves: 23 minutes (92%)

❌ Ignoring Overdue Tasks

Bad:

You have 5 overdue tasks
[Continue working on new tasks instead]

Problem:

• Overdue work piles up
• Important deadlines missed
• Reduces credibility with stakeholders

Good:

You: "Start task session"
Claude: "⚠️ You have 5 overdue tasks"

You: "Show overdue tasks, prioritize by how late"
Claude: "Overdue tasks:
         1. BACKEND-042 (5 days late, critical)
         2. FRONTEND-067 (2 days late, high)
         ..."

You: "Work on BACKEND-042 first"
→ Clear overdue backlog before new work ✅

❌ Creating Circular Dependencies

Bad:

BACKEND-070 depends on FRONTEND-080
FRONTEND-080 depends on BACKEND-070

[Deadlock - neither can be completed]

Good news: ULPI automatically prevents this:

You: "BACKEND-070 depends on FRONTEND-080"
Claude: ✅ Dependency created

You: "FRONTEND-080 depends on BACKEND-070"
Claude: ❌ Error: Circular dependency detected

Prevention is automatic ✅

---

Team Coordination Strategies

Small Team (2-3 agents)

Setup:

• Informal coordination
• Quick daily check-ins
• Shared backlog

Workflow:

Morning:
Each agent: "Start task session"
→ See what others are working on

During day:
Agents pick tasks from shared backlog
Dependencies prevent conflicts

End of day:
Optional: "Show team progress"
→ See what was completed

Coordination time: 5 min/day

Medium Team (4-8 agents)

Setup:

• Designated “lead” agent
• Weekly sprint planning
• Daily async standups

Workflow:

Monday (Sprint Planning):
Lead: "Create 50 tasks for this sprint,
       distribute across team"

Daily:
Each agent: "Start task session"
→ Auto-reports progress
→ Picks next task from backlog

Friday (Retrospective):
Lead: "Show sprint summary"
→ Review completed work
→ Identify bottlenecks

Coordination time: 30 min/week

Large Team (9+ agents)

Setup:

• Multiple sub-teams
• Team leads for each area
• Formal sprint process

Workflow:

Sub-teams:
- Backend team (3 agents)
- Frontend team (3 agents)
- QA team (2 agents)
- DevOps team (2 agents)

Each sub-team:
- Own backlog (tagged by team)
- Team lead assigns work
- Daily sync within team

Cross-team:
- Dependencies managed via tasks
- Weekly sync between leads
- Shared release checklist

Coordination time: 60 min/week

---

Metrics to Track

Velocity

What: Tasks completed per week

Why: Understand team capacity

Query:

"Show completed tasks this week"

Good velocity:

• Solo dev: 8-12 tasks/week
• Small team: 20-30 tasks/week
• Medium team: 50-80 tasks/week

Estimate Accuracy

What: Actual time vs. estimated time

Why: Improve future estimates

Query:

"Show estimate accuracy this month"

Good accuracy:

• 80-120% (within ±20%)
• Consistently low = estimates too conservative
• Consistently high = estimates too optimistic

Overdue Rate

What: % of tasks completed after due date

Why: Identify planning issues

Query:

"How many tasks were completed late this month?"

Good rate:

• Less than 10% overdue
• Greater than 20% = deadlines too aggressive or capacity issues

Blocked Tasks

What: Tasks stuck in “blocked” status

Why: Identify bottlenecks

Query:

"Show blocked tasks"

Good:

• Less than 5% of active tasks blocked
• All blocked tasks have clear owners

Lead Time

What: Time from task creation → completion

Why: Measure delivery speed

Query:

"Show average lead time this month"

Good lead time:

• Small tasks (1-2 hours): Less than 24 hours
• Medium tasks (4-6 hours): 1-2 days
• Large tasks (8+ hours): 2-5 days

Rework Rate

What: Tasks returned from “in_review” → “in_progress”

Why: Quality indicator

Query:

"How many tasks needed rework this week?"

Good rate:

• Less than 15% rework rate
• Greater than 30% = quality issues or unclear requirements

---

What’s Next?

1. Try a Workflow

   Pick one workflow from this guide and try it with your team today

2. Measure Metrics

   Track velocity and estimate accuracy for 2 weeks to establish baseline

3. Check API Reference

   See all available MCP tools for advanced workflows

---

Need Help?

Getting Started

Setup guide

Support

Email us anytime

Community

Join our Discord