Skip to content
Skills Library
Programming · Automation

parallel-yak-implementation

/parallel-yak-implementation

Use when multiple independent leaf yaks are ready to implement and can be worked on concurrently with separate agents in worktrees

Repository
yaks ↗
Licence
MIT
Last repository change
24.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 24.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when multiple independent leaf yaks are ready to implement and can be worked on concurrently with separate agents in worktrees

Original author description

Use when multiple independent leaf yaks are ready to implement and can be worked on concurrently with separate agents in worktrees

How it works

  1. Overview
  2. When to Use
  3. The Process
  4. ⛔ The Main Branch Rule
  5. Common Mistakes
Original SKILL.md headings · 89 lines, 393 words
SKILL.md preview
---
name: parallel-yak-implementation
description: Use when multiple independent leaf yaks are ready to implement and can be worked on concurrently with separate agents in worktrees
---

# Parallel Yak Implementation

## Overview

When multiple leaf yaks are independent and have plans, dispatch
one agent per yak in parallel worktrees. This skill wraps
`superpowers-dev:dispatching-parallel-agents` with yak-specific
lifecycle steps.

## When to Use

- 2+ leaf yaks are ready (have plans, no children)
- The yaks don't modify the same files
- You want to maximize throughput

## The Process

### 1. Identify Ready Leaves

```bash
yx ls
```

Leaf yaks (no children) with plans are candidates. Verify
independence: check their plans don't touch the same files.

### 2. Mark ALL as WIP Before Dispatching

**This is the FIRST thing you do after identifying yaks.**

```bash
yx state "<yak-name>" wip
```

Do this for EVERY yak BEFORE launching any agents. This signals
to the human (and future sessions) what's being worked on.

**Verify with `yx ls`** - all target yaks should show as wip
before you proceed to step 3.

### 3. Dispatch One Agent Per Yak

**REQUIRED:** Use `superpowers-dev:dispatching-parallel-agents`
for the dispatch pattern.

Each agent prompt should include:
- The yak's plan (from `yx field --show "<name>" plan`)
- Instruction to invoke `superpowers-dev:using-git-worktrees`
- Instruction to invoke `superpowers-dev:executing-plans`
- Project context (test commands, commit conventions)
- Clear scope: only work on this yak's files

### 4. When Agents Complete

For each returning agent:
1. Review the summary
2. Verify with `dev check` in the worktree
3. Mark yak done: `yx state "<name>" done`
4. Use `superpowers-dev:finishing-a-development-branch`

If an agent fails, keep the yak as wip and investigate.

## ⛔ The Main Branch Rule

**Neither you nor your subagents may modify main's working
tree.** Main is for merging finished branches only.

- **Subagents** must each work in their own worktree
- **The orchestrating agent** (you) must not stash, clean,
  or edit files on main
- If you see uncommitted changes on main, **stop and ask
  the user** — they belong to someone else

## Common Mistakes

**Working directly on main** - The most dangerous mistake.
Always dispatch subagents with worktree instructions. If a
subagent reports it's working on main, kill it immediately.

**Forgetting to mark wip** - Agents start working but yaks
still show as todo. Always mark wip BEFORE dispatching.

**Overlapping file changes** - If two yaks modify the same
files, work them sequentially instead.

**Not reviewing agent output** - Always verify before marking
done. Agents can make systematic errors.

Versions

The database has no other skills named parallel-yak-implementation.

Database snapshot: 13.11.2026 · package version 726cd77b390c (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100preparing-a-yak
    Use when a yak needs requirements, examples, and a plan before implementation - prepares a yak so it's ready for subagent-driven development
  • 100yak-worktree-workflow
    Use when starting work on a yak - sets up an isolated git worktree, reads yak context, and guides the full cycle from claiming through merge and cleanup
  • 100git-worktrees-parallel-feature-development
    Use this skill when working across multiple Git branches simultaneously in separate directories without stashing.
  • 100parallel-worktrees
    Run multiple AI coding agent sessions in parallel using git worktrees — each agent isolated in its own worktree, working on a separate branch. Use this skill whenever the user wants to: run two or more AI agents simultaneously on different features or bugs, set up isolated agent…
  • 100merging-worktrees
    Use when merging parallel worktrees back together after parallel implementation, combining parallel development tracks, or unifying branches from dispatched parallel agents. Triggers: 'merge worktrees', 'combine parallel branches', 'integrate parallel work', 'all tracks…
  • 100execute
    Dispatch and execute implementation plans with TDD and checkpoints. Use when plan is ready. Parallel by default for independent tasks.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.