Skip to main content

​
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
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)

​
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
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 minutesTraditional planning: 30 minutes (meeting, discussion, Jira tickets)Time saved: 28 minutes

​
Workflow 3: Bug Fix Sprint

Use case: Fix 50 production bugs in 48 hours Team: 5 developers with AI assistants
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

​
Workflow 4: Release Preparation

Use case: Prepare for production release (checklist completion)
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"

​
Workflow 5: Onboarding New AI Agent

Use case: Add a new AI assistant to existing team
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)

​
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 secondSaves: 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 secondsSaves: 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)

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 ✅
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
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 minutesProblem:
  • Tedious and error-prone
  • Inconsistent formatting
  • Miss dependencies
Good:
"Create 50 tasks from this list:
 [paste all 50 tasks]

 Auto-infer dependencies"
Time: 2 minutesSaves: 23 minutes (92%)
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 ✅
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

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

​
Metrics to Track

Velocity

What: Tasks completed per weekWhy: Understand team capacityQuery:
"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 timeWhy: Improve future estimatesQuery:
"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 dateWhy: Identify planning issuesQuery:
"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” statusWhy: Identify bottlenecksQuery:
"Show blocked tasks"
Good:
  • Less than 5% of active tasks blocked
  • All blocked tasks have clear owners

Lead Time

What: Time from task creation → completionWhy: Measure delivery speedQuery:
"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 indicatorQuery:
"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