New: 97,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Parallel Execution

by CloudAI-X in CloudAI-X/opencode-workflow

CRITICAL skill for executing multiple Task tool calls in a SINGLE message for true parallelism.

MITAuto-check passedAgent Workflows

Install Parallel Execution

skills CLI
$ npx skills add CloudAI-X/opencode-workflow --skill parallel-execution -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install CloudAI-X/opencode-workflow parallel-execution --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/CloudAI-X/opencode-workflow.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/parallel-execution .claude/skills/parallel-execution && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
parallel-execution
GitHub stars
275
Token cost
~2.1k tokens
SKILL.md length
355 words
Files
1
Skills in repo
7
Repo updated
First seen
Licence
MIT

At a glance

CRITICAL skill for executing multiple Task tool calls in a SINGLE message for true parallelism.

  • Works in 3 steps: Identify Independent Tasks → Launch ALL Tasks in ONE Message → Collect and Synthesize Results
  • Tasks that involve Subagents
  • SKILL.md covers The Fundamental Rule, Why Parallel Execution Matters, How to Execute in Parallel and Parallelization Patterns, plus 7 more sections
  • Calls just

What it does

Parallel Execution is an agent skill from CloudAI-X/opencode-workflow. CRITICAL skill for executing multiple Task tool calls in a SINGLE message for true parallelism. Essential for efficient multi-task workflows, subagent coordination, and maximizing throughput.

Its SKILL.md is about 2.1k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts. Compatibility notes: opencode

It sits in Agent Workflows, covering Subagents. The licence is MIT.

When your agent uses it

  • Tasks that involve Subagents

Example prompts

  • “/parallel-execution”

Requirements

  • Compatibility (from SKILL.md): opencode

Workflow steps

3 steps, taken from the step headings in SKILL.md.

  1. Identify Independent Tasks
  2. Launch ALL Tasks in ONE Message
  3. Collect and Synthesize Results

What it can do on your machine

Read from SKILL.md and the folder at commit 0128ca6. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • just

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

  • Compatibility

    opencode

    From compatibility in the SKILL.md frontmatter.

Context cost

Parallel Execution loads about 2.1k tokens when it runs. Until then it costs about 53 tokens; SKILL.md has 355 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~53
When it runs · the whole SKILL.md, loaded when a task matches
~2.1k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from CloudAI-X/opencode-workflow at commit 0128ca6, republished under its MIT licence (© CloudAI-X). 355 words, ~2,099 tokens.

Download SKILL.mdSave it as .claude/skills/parallel-execution/SKILL.md (or your agent's skills folder).
name
parallel-execution
description
CRITICAL skill for executing multiple Task tool calls in a SINGLE message for true parallelism. Essential for efficient multi-task workflows, subagent coordination, and maximizing throughput.
compatibility
opencode
license
MIT
metadata.category
workflow
metadata.audience
agents

Parallel Execution

CRITICAL: This skill teaches how to execute multiple tasks simultaneously for maximum efficiency.

The Fundamental Rule

ALL Task calls MUST be in a SINGLE assistant message for true parallelism.

If Task calls are in separate messages, they run SEQUENTIALLY, not in parallel.

Why Parallel Execution Matters

Sequential (SLOW - AVOID)
Message 1: Start Task A
           ↓ wait for completion
Message 2: Start Task B
           ↓ wait for completion
Message 3: Start Task C
           ↓ wait for completion

Total time = A + B + C = 90 seconds (if each takes 30s)
Parallel (FAST - USE THIS)
Message 1: Start Task A ─┐
           Start Task B ─┼─ All run simultaneously
           Start Task C ─┘

Total time ≈ max(A, B, C) = 30 seconds

Speedup: 3x faster with 3 parallel tasks

How to Execute in Parallel

Step 1: Identify Independent Tasks

Tasks are independent when:

  • They don't depend on each other's output
  • They don't modify the same files
  • They can run in any order
Step 2: Launch ALL Tasks in ONE Message
xml
<!-- CORRECT: All tasks in single message = PARALLEL -->
<task>
  <description>Analyze authentication module</description>
  <prompt>Review src/auth for security patterns...</prompt>
</task>

<task>
  <description>Analyze API layer</description>
  <prompt>Review src/api for REST best practices...</prompt>
</task>

<task>
  <description>Analyze database layer</description>
  <prompt>Review src/db for query optimization...</prompt>
</task>
Step 3: Collect and Synthesize Results

After all tasks complete, combine their findings into a unified response.

Parallelization Patterns

Pattern 1: Task-Based Parallelization

When you have N independent tasks, spawn N subagents:

Implementation Plan:
1. Implement auth module
2. Create API endpoints
3. Add database schema
4. Write unit tests
5. Update documentation

Launch 5 parallel subagents:
├─ Subagent 1: Implement auth module
├─ Subagent 2: Create API endpoints
├─ Subagent 3: Add database schema
├─ Subagent 4: Write unit tests
└─ Subagent 5: Update documentation

All 5 in ONE message!

Pattern 2: Directory-Based Parallelization

Analyze different directories simultaneously:

Codebase Structure:
├── src/auth/
├── src/api/
├── src/db/
└── src/ui/

Launch 4 parallel subagents:
├─ Subagent 1: Analyze src/auth
├─ Subagent 2: Analyze src/api
├─ Subagent 3: Analyze src/db
└─ Subagent 4: Analyze src/ui
Pattern 3: Perspective-Based Parallelization

Review from multiple angles at once:

Code Review Perspectives:
- Security vulnerabilities
- Performance bottlenecks
- Test coverage gaps
- Architecture patterns

Launch 4 parallel subagents:
├─ Subagent 1: Security review
├─ Subagent 2: Performance analysis
├─ Subagent 3: Test coverage review
└─ Subagent 4: Architecture assessment
Pattern 4: Adversarial Verification

Use conflicting mandates for thorough review:

Verification Subagents (all parallel):
├─ Syntax & Type Checker
├─ Test Runner
├─ Lint & Style Checker
├─ Security Scanner
└─ Build Validator

Then (sequential, after above complete):
├─ False Positive Filter
├─ Missing Issues Finder
└─ Context Validator

TodoWrite Integration

When using parallel execution, mark ALL parallel tasks as in_progress simultaneously:

Before Launching Parallel Tasks
json
{
  "todos": [
    { "content": "Analyze auth module", "status": "in_progress", "activeForm": "Analyzing auth module" },
    { "content": "Analyze API layer", "status": "in_progress", "activeForm": "Analyzing API layer" },
    { "content": "Analyze database layer", "status": "in_progress", "activeForm": "Analyzing database layer" },
    { "content": "Synthesize findings", "status": "pending", "activeForm": "Synthesizing findings" }
  ]
}
After Each Task Completes

Mark as completed as results come in:

json
{
  "todos": [
    { "content": "Analyze auth module", "status": "completed", "activeForm": "Analyzing auth module" },
    { "content": "Analyze API layer", "status": "completed", "activeForm": "Analyzing API layer" },
    { "content": "Analyze database layer", "status": "in_progress", "activeForm": "Analyzing database layer" },
    { "content": "Synthesize findings", "status": "pending", "activeForm": "Synthesizing findings" }
  ]
}

When to Parallelize

Show full SKILL.md (156 more words)Show less
Good Candidates
ScenarioParallel Approach
Multiple independent analysesOne subagent per analysis
Multi-file processingOne subagent per file/directory
Different review perspectivesOne subagent per perspective
Multiple independent featuresOne subagent per feature
Exploratory researchMultiple search strategies
When NOT to Parallelize
ScenarioWhy Sequential
Tasks with dependenciesB needs A's output
Same file modificationsRisk of conflicts
Sequential workflowsOrder matters (commit → push → PR)
Shared stateRace conditions
Limited resourcesOverwhelming the system

Performance Impact

# Parallel TasksSequential TimeParallel TimeSpeedup
260s30s2x
390s30s3x
5150s30s5x
10300s30s10x

Assuming each task takes ~30 seconds

Common Mistakes

Mistake 1: Separate Messages
WRONG (Sequential):
Message 1: "I'll start analyzing the auth module..."
           <task>Analyze auth</task>
Message 2: "Now let me analyze the API..."
           <task>Analyze API</task>

RIGHT (Parallel):
Message 1: "I'll analyze all modules in parallel..."
           <task>Analyze auth</task>
           <task>Analyze API</task>
           <task>Analyze DB</task>
Mistake 2: Announcing Before Acting
WRONG:
"I'm going to launch three parallel tasks to analyze the codebase."
[waits for response]
"Now launching the tasks..."

RIGHT:
"Launching three parallel analysis tasks now:"
<task>...</task>
<task>...</task>
<task>...</task>
Mistake 3: Forgetting Synthesis
WRONG:
Just dump all task outputs without integration

RIGHT:
After receiving all results, synthesize:
- Identify common themes
- Resolve contradictions
- Prioritize findings
- Create unified recommendations

Parallel Execution Checklist

Before launching parallel tasks, verify:

  • Tasks are truly independent
  • No shared file modifications
  • No sequential dependencies
  • All tasks in SINGLE message
  • TodoWrite updated with all in_progress
  • Synthesis step planned

Template: Parallel Analysis

markdown
## Launching Parallel Analysis

I'm analyzing this codebase from multiple perspectives simultaneously.

### Parallel Tasks

<task description="Security Review">
Analyze for security vulnerabilities, focusing on:
- Authentication/authorization
- Input validation
- Secrets handling
</task>

<task description="Performance Review">
Analyze for performance issues, focusing on:
- N+1 queries
- Memory leaks
- Blocking operations
</task>

<task description="Test Coverage Review">
Analyze test coverage, focusing on:
- Missing test cases
- Edge cases
- Integration tests
</task>

### Synthesis (after all complete)

[Combine findings into prioritized report]

Quick Reference

RULE #1:
  ALL Task calls in SINGLE message = PARALLEL
  Task calls in SEPARATE messages = SEQUENTIAL

PATTERNS:
  Task-based:       One subagent per task
  Directory-based:  One subagent per directory
  Perspective-based: One subagent per viewpoint
  Adversarial:      Multiple competing reviewers

TODOWRITE:
  Mark ALL parallel tasks as in_progress BEFORE launching
  Mark each as completed AFTER receiving results

SPEEDUP:
  N parallel tasks ≈ Nx faster
  (5 tasks @ 30s each: 150s → 30s)

CHECKLIST:
  ☐ Tasks independent?
  ☐ No shared files?
  ☐ No dependencies?
  ☐ All in ONE message?
  ☐ Synthesis planned?

© CloudAI-X, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/parallel-execution of CloudAI-X/opencode-workflow.

Open the folder on GitHubat commit 0128ca6

Compare with similar skills

Parallel Execution next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Parallel Execution compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Parallel Execution this skillCloudAI-X/opencode-workflow275—~2.1kAutomated safety check: PassMIT
Claude Code Agent Developmentanthropics/claude-plugins-official37k8 repos~2.8kAutomated safety check: PassApache-2.0
Subagent Driven DevelopmentAsvarox/allkaraoke26137 repos~1.2kAutomated safety check: PassNone
Dispatching Parallel Agentsultralisp/ultralisp25840 repos~1.5kAutomated safety check: PassNone
Paseo Advisor Second Opiniongetpaseo/paseo20k1 repos~756Automated safety check: PassCustom licence
Task Observerrebelytics/one-skill-to-rule-them-all3.2k1 repos~12kAutomated safety check: PassCC-BY-4.0

Similar skills

  • Claude Code Agent Development

    anthropics/claude-plugins-official

    Official

    Explains how to write agents for Claude Code plugins: the markdown file with YAML frontmatter, trigger descriptions, model and color settings, and system prompt design.

    37k GitHub starsUsed in 8 repos~2.8k tokens
    Agent WorkflowsAuto-check passed

  • Subagent Driven Development

    Asvarox/allkaraoke

    A skill your agent uses when executing implementation plans with independent tasks in the current session

    261 GitHub starsUsed in 37 repos~1.2k tokens
    Agent WorkflowsAuto-check passed

  • Dispatching Parallel Agents

    ultralisp/ultralisp

    A skill your agent uses when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies

    258 GitHub starsUsed in 40 repos~1.5k tokens
    Agent WorkflowsAuto-check passed

  • Paseo Advisor Second Opinion

    getpaseo/paseo

    Launches one separate agent through Paseo to give a second opinion on the current task, with a self-contained briefing and no permission to edit files.

    20k GitHub starsUsed in 1 repo~756 tokens
    Agent WorkflowsAuto-check passed

  • Task Observer

    rebelytics/one-skill-to-rule-them-all

    Monitors task execution for skill improvement opportunities.

    3.2k GitHub starsUsed in 1 repo~12k tokens
    Agent WorkflowsAuto-check passed

  • O2 Review Loop

    openobserve/openobserve

    Splits a change into planner, coder and independent reviewer roles: you confirm a spec, a subagent implements it, and a separate reviewer checks each round's local WIP commit.

    22k GitHub stars~3.7k tokensUpdated today
    Agent WorkflowsAuto-check passed

More from CloudAI-X/opencode-workflow

  • Analyzing Projects

    CloudAI-X/opencode-workflow

    Guides systematic project analysis, codebase exploration, and architecture pattern recognition.

    275 GitHub starsUsed in 1 repo~1.8k tokens
    Auto-check passed

  • Designing APIs

    CloudAI-X/opencode-workflow

    Guides REST and GraphQL API design, endpoint patterns, request/response schemas, versioning, and API best practices.

    275 GitHub starsUsed in 1 repo~2.2k tokens
    Auto-check passed

  • Designing Architecture

    CloudAI-X/opencode-workflow

    Guides software architecture decisions, design patterns, and system design principles.

    275 GitHub stars~2.6k tokensUpdated 9 mo ago
    Auto-check passed

  • Designing Tests

    CloudAI-X/opencode-workflow

    Guides test strategy, TDD/BDD approaches, test coverage planning, and testing best practices.

    275 GitHub stars~2.9k tokensUpdated 9 mo ago
    Auto-check passed

  • Managing Git

    CloudAI-X/opencode-workflow

    Guides git workflows, branching strategies, commit conventions, and version control best practices.

    275 GitHub stars~2.5k tokensUpdated 9 mo ago
    Auto-check passed

  • Optimizing Performance

    CloudAI-X/opencode-workflow

    Guides performance optimization, profiling techniques, and bottleneck identification.

    275 GitHub stars~2.6k tokensUpdated 9 mo ago
    Auto-check passed

Categories

Questions about Parallel Execution

What does Parallel Execution do?

CRITICAL skill for executing multiple Task tool calls in a SINGLE message for true parallelism. Parallel Execution is an agent skill from CloudAI-X/opencode-workflow. CRITICAL skill for executing multiple Task tool calls in a SINGLE message for true parallelism.

When should I use Parallel Execution?

Parallel Execution fits situations like: tasks that involve Subagents.

How do I install Parallel Execution in Claude Code?

Run `npx skills add CloudAI-X/opencode-workflow --skill parallel-execution -a claude-code`. Or copy the skill folder (skills/parallel-execution in CloudAI-X/opencode-workflow) into .claude/skills/parallel-execution in your project. Claude Code loads it when a task matches its description.

How do I install Parallel Execution in Codex?

Run `npx skills add CloudAI-X/opencode-workflow --skill parallel-execution -a codex`. Or copy the skill folder (skills/parallel-execution in CloudAI-X/opencode-workflow) into .agents/skills/parallel-execution in your project. Codex loads it when a task matches its description.

Can I use Parallel Execution in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add CloudAI-X/opencode-workflow --skill parallel-execution -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/parallel-execution, .gemini/skills/parallel-execution, .github/skills/parallel-execution and .opencode/skills/parallel-execution in your project.

What does Parallel Execution need to run?

Going by SKILL.md and its folder, Parallel Execution needs the command-line tools its instructions call (just). Compatibility (from SKILL.md): opencode.

Does Parallel Execution access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Parallel Execution safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Parallel Execution use?

Parallel Execution is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Parallel Execution use?

About 2.1k tokens (SKILL.md is roughly 8.4k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Parallel Execution?

Skills that share tags, products or a category with Parallel Execution: Claude Code Agent Development (anthropics/claude-plugins-official, 37k stars), Subagent Driven Development (Asvarox/allkaraoke, 261 stars), Dispatching Parallel Agents (ultralisp/ultralisp, 258 stars) and Paseo Advisor Second Opinion (getpaseo/paseo, 20k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Parallel Execution?

CloudAI-X (a GitHub user) maintains it in CloudAI-X/opencode-workflow, which has 275 GitHub stars. The repository holds 7 skills in this directory. The repository was last updated on January 10, 2026.

Source: CloudAI-X/opencode-workflow on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.