> ## Documentation Index
> Fetch the complete documentation index at: https://ulpi.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# 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.

<Info>
  **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
</Info>

***

## Workflow 1: Daily Development Cycle

**Use case:** Solo developer with 1 AI assistant

**Time:** 15 seconds per day

<Tabs>
  <Tab title="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

    <Check>
      **Time saved:** 5 minutes per day

      (No need to check dashboard, filter tasks, calculate priorities manually)
    </Check>
  </Tab>

  <Tab title="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)
  </Tab>

  <Tab title="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)
  </Tab>
</Tabs>

***

## 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

<Tabs>
  <Tab title="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!"
    ```

    <Check>
      **Planning time:** 2 minutes

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

      **Time saved:** 28 minutes
    </Check>
  </Tab>

  <Tab title="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)
  </Tab>

  <Tab title="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
    ```
  </Tab>

  <Tab title="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)
    ```

    <Check>
      **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%**
    </Check>
  </Tab>
</Tabs>

***

## Workflow 3: Bug Fix Sprint

**Use case:** Fix 50 production bugs in 48 hours

**Team:** 5 developers with AI assistants

<Tabs>
  <Tab title="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
  </Tab>

  <Tab title="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)
    ```
  </Tab>

  <Tab title="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 ✅
    ```
  </Tab>

  <Tab title="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)
    ```
  </Tab>
</Tabs>

***

## Workflow 4: Release Preparation

**Use case:** Prepare for production release (checklist completion)

<Tabs>
  <Tab title="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"
    ```
  </Tab>

  <Tab title="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 ✅"
    ```
  </Tab>

  <Tab title="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)
  </Tab>
</Tabs>

***

## Workflow 5: Onboarding New AI Agent

**Use case:** Add a new AI assistant to existing team

<Tabs>
  <Tab title="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)
  </Tab>

  <Tab title="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)"
    ```
  </Tab>

  <Tab title="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)
  </Tab>
</Tabs>

***

## Best Practices

<CardGroup cols={2}>
  <Card title="1. Start Every Session with 'Start Task Session'" icon="power-off">
    **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
  </Card>

  <Card title="2. Use Bulk Operations for Planning" icon="layer-group">
    **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
  </Card>

  <Card title="3. Let Dependencies Prevent Blocking" icon="link">
    **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
    ```
  </Card>

  <Card title="4. Track Time to Improve Estimates" icon="clock">
    **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
  </Card>

  <Card title="5. Use Tags for Filtering" icon="tags">
    **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
    ```
  </Card>

  <Card title="6. Claim Work Based on Capacity" icon="gauge">
    **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
    ```
  </Card>
</CardGroup>

***

## Anti-Patterns (What NOT to Do)

<AccordionGroup>
  <Accordion title="❌ Creating Tasks Without Dependencies" icon="link-slash">
    **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 ✅
    ```
  </Accordion>

  <Accordion title="❌ Vague Task Titles" icon="heading">
    **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
    ```
  </Accordion>

  <Accordion title="❌ Not Using Bulk Operations" icon="xmark">
    **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%)
  </Accordion>

  <Accordion title="❌ Ignoring Overdue Tasks" icon="calendar-xmark">
    **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 ✅
    ```
  </Accordion>

  <Accordion title="❌ Creating Circular Dependencies" icon="circle-exclamation">
    **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** ✅
  </Accordion>
</AccordionGroup>

***

## Team Coordination Strategies

<Tabs>
  <Tab title="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
  </Tab>

  <Tab title="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
  </Tab>

  <Tab title="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
  </Tab>
</Tabs>

***

## Metrics to Track

<CardGroup cols={2}>
  <Card title="Velocity" icon="gauge-high">
    **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
  </Card>

  <Card title="Estimate Accuracy" icon="bullseye">
    **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
  </Card>

  <Card title="Overdue Rate" icon="calendar-xmark">
    **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
  </Card>

  <Card title="Blocked Tasks" icon="hand">
    **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
  </Card>

  <Card title="Lead Time" icon="hourglass">
    **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
  </Card>

  <Card title="Rework Rate" icon="rotate-left">
    **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
  </Card>
</CardGroup>

***

## What's Next?

<Steps>
  <Step title="Try a Workflow">
    Pick one workflow from this guide and try it with your team today
  </Step>

  <Step title="Measure Metrics">
    Track velocity and estimate accuracy for 2 weeks to establish baseline
  </Step>

  <Step title="Check API Reference">
    [See all available MCP tools](/tasks/api-reference) for advanced workflows
  </Step>
</Steps>

***

## Need Help?

<CardGroup cols={3}>
  <Card title="Getting Started" icon="rocket" href="/tasks/getting-started">
    Setup guide
  </Card>

  <Card title="Support" icon="life-ring" href="mailto:support@ulpi.io">
    Email us anytime
  </Card>

  <Card title="Community" icon="discord" href="https://discord.gg/ulpi">
    Join our Discord
  </Card>
</CardGroup>