Skip to main content

​
The Problem: Creating Tasks One-by-One is Slow

You need to create 50 tasks for a major feature:
"Create task 1: Add database schema"
"Create task 2: Implement endpoints"
"Create task 3: Add frontend UI"
...
[45 more times]
Result:
  • ⏱️ 25 minutes to create 50 tasks
  • 😫 Tedious and error-prone
  • 🐛 Forget dependencies between tasks
  • 📋 Inconsistent task naming/tagging
Real scenario:Developer planning a major refactor needed 80 tasks. Spent 40 minutes creating them one by one. Made mistakes in 12 tasks (wrong priority, missing dependencies).

​
Bulk Operations

Pro Feature: Bulk operations require Pro or Enterprise plan.Starter plan: Create tasks one at a time only.

​
Bulk Create Tasks

Create up to 100 tasks in a single operation.
Describe tasks in plain English:
You: "Create tasks for implementing a blog feature:

      1. Add blog posts database table
      2. Create API endpoints for CRUD operations
      3. Build admin UI for managing posts
      4. Add markdown editor component
      5. Create public blog listing page
      6. Add RSS feed generation
      7. Implement blog search
      8. Add comment system
      9. Create email notifications for new posts
      10. Write integration tests"

Claude: "Creating 10 tasks with inferred dependencies...

         ✅ BACKEND-090: Add blog posts database table
         ✅ BACKEND-091: Create blog CRUD API endpoints
            (depends on BACKEND-090)
         ✅ FRONTEND-120: Build admin UI for blog posts
            (depends on BACKEND-091)
         ✅ FRONTEND-121: Add markdown editor component
            (depends on FRONTEND-120)
         ✅ FRONTEND-122: Create public blog listing page
            (depends on BACKEND-091)
         ✅ BACKEND-092: Add RSS feed generation
            (depends on BACKEND-091)
         ✅ BACKEND-093: Implement blog search
            (depends on BACKEND-091)
         ✅ BACKEND-094: Add comment system
            (depends on BACKEND-091)
         ✅ BACKEND-095: Email notifications for new posts
            (depends on BACKEND-091)
         ✅ TEST-045: Blog integration tests
            (depends on all above)

         Created 10 tasks in 1.2 seconds
         Dependencies: 9 automatic dependencies created"
AI automatically:
  • Detects task order (DB → API → UI → Tests)
  • Creates dependency chain
  • Assigns task types (backend, frontend, test)
  • Sets reasonable priorities

​
Macro Tools

Pre-built workflows for common task operations.
What it does:
  1. Registers your agent (if not already registered)
  2. Fetches all tasks assigned to you
  3. Shows statistics (total, by status, overdue, etc.)
When to use: At the start of every work sessionExample:
You: "Start task session"

Claude: "# Task Session Started

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

         ## Your Statistics

         Total Assigned: 47 tasks
         - Todo: 12
         - In Progress: 3
         - Blocked: 1
         - In Review: 2
         - Completed: 29

         ⚠️ Overdue Tasks: 2
         🔥 Critical Priority: 1

         Avg Completion Time: 4.2 hours

         ## Your Active Tasks (15)

         ### BACKEND-042: Implement OAuth endpoints
         - Status: in_progress
         - Priority: high
         - Due: 2025-01-15 (3 days)

         ### BACKEND-045: Add rate limiting
         - Status: in_progress
         - Priority: critical
         - Due: 2025-01-13 (OVERDUE by 1 day) 🔴

         ### BACKEND-050: Refactor auth controller
         - Status: in_progress
         - Priority: medium

         [... 12 more tasks ...]"
Benefits:
  • ✅ One command instead of 3 separate operations
  • ✅ Instant overview of your work
  • ✅ Automatic agent registration (zero setup)
  • ✅ Highlights urgent work (overdue, critical priority)
What it does:
  1. Searches for unassigned tasks matching your capabilities
  2. Shows tasks sorted by priority and due date
  3. Claims tasks for you (marks as assigned and in_progress)
When to use: When you finish current work and need new tasksExample:
You: "Claim tasks matching my capabilities:
      backend development, API design"

Claude: "Searching for unassigned tasks...

         Found 8 matching tasks:

         High Priority:
         1. BACKEND-088: Add OAuth scopes (4 hours)
         2. BACKEND-092: Implement rate limiting (3 hours)

         Medium Priority:
         3. BACKEND-095: Add API versioning (5 hours)
         4. BACKEND-098: Optimize database queries (6 hours)

         Low Priority:
         5. BACKEND-101: Add API documentation (2 hours)
         6. BACKEND-103: Refactor error handling (4 hours)

         How many would you like to claim?"

You: "Claim the top 3"

Claude: "✅ Claimed 3 tasks:
         - BACKEND-088: Assigned to you, marked as in_progress
         - BACKEND-092: Assigned to you, status: todo
         - BACKEND-095: Assigned to you, status: todo

         Estimated workload: 12 hours
         Recommended completion: 1.5 days"
Smart matching:
  • Filters by agent capabilities
  • Respects priority and due dates
  • Avoids overloading (checks current workload)
  • Considers dependencies (won’t claim blocked tasks)
Pro Feature: Macro tools require Pro or Enterprise plan
What it does:
  1. Fetches a task and all its dependencies
  2. Checks if dependencies are completed
  3. Gathers context from related tasks
  4. Prepares work summary for agent
When to use: Before starting work on a complex taskExample:
You: "Prepare to work on BACKEND-092"

Claude: "# Task: BACKEND-092 (Implement Rate Limiting)

         ## Task Details
         Type: feature
         Priority: high
         Estimate: 3 hours
         Due: 2025-01-16 (4 days)
         Assigned: claude-desktop-main

         ## Dependencies
         ✅ BACKEND-088: Add OAuth scopes (completed 2 days ago)
         ✅ BACKEND-085: Set up Redis cache (completed 1 week ago)

         All dependencies completed ✅ Ready to start

         ## Related Context
         - Similar implementation: BACKEND-067 (API throttling)
         - Configuration file: config/rate-limit.php
         - See documentation: docs/rate-limiting.md

         ## Suggested Approach
         Based on BACKEND-067:
         1. Add rate limit middleware
         2. Configure Redis for rate limit storage
         3. Add rate limit headers to responses
         4. Write integration tests

         ## Ready to Start?
         Reply 'yes' to mark as in_progress"
Benefits:
  • ✅ Verifies dependencies before you start
  • ✅ Gathers context from related tasks
  • ✅ Suggests approach based on similar completed work
  • ✅ Saves 10-15 minutes of research per task

​
Parallel Execution Patterns

​
Pattern 1: Sprint Planning (Bulk Create + Auto-Assign)

Scenario: Plan entire 2-week sprint in 5 minutes
Team:
  • Claude (backend): 40 hours capacity
  • Cursor (frontend): 40 hours capacity
  • Windsurf (QA): 20 hours capacity
Features to ship:
  1. User roles & permissions (20 hours)
  2. Email notifications (12 hours)
  3. Dashboard redesign (15 hours)
  4. API rate limiting (8 hours)
  5. Bug fixes from last sprint (10 hours)

​
Pattern 2: Bug Triage (Bulk Import + Macro Claim)

Scenario: 50 bugs reported from production monitoring
You have: JSON export from error tracking (Sentry, Rollbar, etc.)
{
  "errors": [
    {
      "id": "ERR-1001",
      "message": "Database connection timeout",
      "severity": "critical",
      "count": 1247,
      "first_seen": "2025-01-10",
      "affected_users": 523
    },
    {
      "id": "ERR-1002",
      "message": "API rate limit exceeded",
      "severity": "high",
      "count": 892,
      "affected_users": 201
    },
    // ... 48 more errors
  ]
}
Bulk import:
You: "Import these 50 errors as bug tasks,
      prioritize by severity and user impact"

Claude: "Importing 50 bugs...

         ✅ Created 50 bug tasks
         ✅ Priorities assigned:
            - 5 critical (1000+ users affected)
            - 15 high (100+ users affected)
            - 20 medium (10+ users affected)
            - 10 low (<10 users affected)

         ✅ Auto-tagged based on error type:
            - 23 tasks: #backend
            - 12 tasks: #frontend
            - 8 tasks: #database
            - 7 tasks: #api

         Total time: 1.8 seconds"

​
Pattern 3: Refactoring Project (100+ Tasks)

Scenario: Major codebase refactor, 150 tasks over 4 weeks
Generate task list from codebase analysis:
You: "Analyze codebase and generate refactoring tasks:
      - Split large files (>500 lines)
      - Extract duplicate code
      - Add missing types
      - Update deprecated APIs
      - Improve test coverage"

Claude: "Analyzing codebase...

         Found refactoring opportunities:
         - 45 files > 500 lines
         - 23 instances of duplicate code
         - 67 files missing TypeScript types
         - 12 deprecated API usages
         - 34 files with < 50% test coverage

         Creating 150 refactoring tasks...

         ✅ Created 150 tasks in 6 categories
         ✅ Estimated total effort: 320 hours
         ✅ Suggested timeline: 4 weeks (2 devs)

         Task breakdown:
         - Split large files: 45 tasks (90 hours)
         - Extract duplicates: 23 tasks (46 hours)
         - Add types: 67 tasks (100 hours)
         - Update deprecated APIs: 12 tasks (24 hours)
         - Improve test coverage: 34 tasks (60 hours)

         Dependencies created: 89 automatic dependencies
         (e.g., 'add types' before 'split files')

         Total time: 4.7 seconds"

​
Performance & Limits

Starter Plan:
- Bulk operations: ❌ Not available
- Must create tasks one-by-one

Pro Plan:
- Max tasks per bulk operation: 100
- Max bulk operations per day: 50
- Total: 5,000 tasks per day

Enterprise Plan:
- Max tasks per bulk operation: 1,000
- Max bulk operations per day: Unlimited
- Rate limit: 100 requests/second

​
Common Workflows

Steps:
  1. Export last sprint’s velocity 
    "Show completed tasks from last 2 weeks with time estimates"
→ Avg velocity: 45 hours/sprint
  2. Bulk create next sprint tasks 
    "Create 50 tasks for next sprint from feature list"
→ 50 tasks created in 1.2 seconds
  3. Auto-assign based on capacity 
    "Assign tasks to team based on 45 hours capacity each"
→ Tasks distributed across 3 agents
  4. Set sprint milestone 
    "Tag all sprint tasks with 'sprint-12'"
→ 50 tasks tagged
  5. Daily standup queries 
    "Show sprint-12 progress"
→ Real-time dashboard
Time: 10 minutes for entire sprint planning
Steps:
  1. Import bugs from tracking tool 
    "Import 100 bugs from Sentry JSON export"
→ 100 bug tasks created
  2. Auto-prioritize by severity 
    Critical: 12 bugs
High: 34 bugs
Medium: 42 bugs
Low: 12 bugs
  3. Team claims bugs 
    Each agent: "Claim critical bugs in my specialty"
→ All critical bugs claimed within 5 minutes
  4. Track resolution rate 
    "Show bug fix velocity"
→ 8 bugs/hour team average
→ ETA: 12.5 hours to fix all bugs
Result: 100 bugs → organized & assigned in 15 minutes
Scenario: Migrate from Angular to React (200+ components)Steps:
  1. Generate migration tasks from codebase 
    "Analyze Angular codebase and create React migration tasks"
→ 237 component migration tasks created
  2. Create dependency graph 
    "Set dependencies: migrate parent components first"
→ 184 automatic dependencies created
  3. Incremental claiming 
    Daily: "Claim 5 leaf components (no dependents)"
→ Agents work on independent components
→ Zero blocking
  4. Track migration progress 
    "Show migration percentage"
→ 142/237 components migrated (60%)
→ 15 components in progress
→ 80 components todo
Timeline: 6 weeks, 3 devs, 237 components

​
What’s Next?

1

Learn Common Workflows

Explore workflow patterns and best practices
2

Check API Reference

See detailed documentation for all MCP tools
3

Try Bulk Operations

Create your first 50-task sprint plan using bulk operations

​
Need Help?

Getting Started

Quick setup guide

Support

Email us anytime

Community

Join our Discord