executing-work-items

name	executing-work-items
description	Executes specific work items ad-hoc using AI agents with intelligent dependency analysis and parallelization. Use when you need to implement one or more specific items outside of a formal sprint, or when testing implementation of individual features.
disable-model-invocation	true

Executing Work Items

Execute specific work items using AI agents with dependency resolution and parallel execution.

Usage

/executing-work-items <item-ids...> [options]

Arguments

Item IDs (required):

• One or more work item IDs (e.g., CCC-123 CCC-124 CCC-125)
• Or comma-separated: CCC-123,CCC-124,CCC-125

Options:

• --dry-run: Preview execution plan without running
• --force: Execute despite blockers or incomplete dependencies
• --skip-prep: Skip readiness validation

Examples

# Execute single item
/executing-work-items CCC-123

# Execute multiple items
/executing-work-items CCC-123 CCC-124 CCC-125

# Preview plan only
/executing-work-items CCC-123 CCC-124 --dry-run

# Force execution (use with caution)
/executing-work-items CCC-123 --force

Workflow

Step 1: Gather Item Context

For each item:

item = pm_context.get_item(item_id)
item.children = pm_context.get_children(item_id)
item.parent = pm_context.get_item(item.parent_id) if item.parent_id else None

Step 2: Readiness Validation

Unless --skip-prep:

• Check all items have acceptance criteria
• Check for blocking dependencies
• Verify parent items exist (if specified)

Step 3: Dependency Analysis

# Check dependencies between items
for item in items:
    if item.blocked_by:
        blocker = pm_context.get_item(item.blocked_by)
        if blocker.status_type != "done":
            if blocker.id in item_ids:
                # Will execute in this batch - OK
                dependencies.append((blocker.id, item.id))
            else:
                # External dependency - warn
                warnings.append(f"{item.key} blocked by {blocker.key}")

Step 4: Code Analysis

Launch parallel analysis for each item:

• Identify files to modify
• Check for conflicts between items
• Plan implementation approach

Step 5: Plan Execution

Group items by:

• File overlap (same files → same agent)
• Dependencies (blocker runs first)
• Stack area (frontend, backend)

Assign to agents (max 4 parallel).

Step 6: Execute

Phase 1: Dependencies Execute blocking items first.

Phase 2: Parallel Run independent items in parallel.

Step 7: Report

## Execution Complete

### Items Executed: {count}/{total}

| Item | Status | Agent | Duration |
|------|--------|-------|----------|
{for item in items:}
| {item.key} | {status} | Agent-{n} | {duration} |

### Files Modified
{list of files}

### Next Steps
{any follow-up recommendations}

Use Cases

Ad-hoc Bug Fix

/executing-work-items BUG-456

Feature Testing

/executing-work-items FEAT-123 --dry-run
# Review plan, then:
/executing-work-items FEAT-123

Batch Task Execution

/executing-work-items TASK-1 TASK-2 TASK-3 TASK-4

Invocation Control

This skill has disable-model-invocation: true because:

• Launches agents with side effects
• Modifies code and PM tool status
• User should explicitly control execution