kkrafft1999/snotra / .claude/skills/parallel-tasks
parallel-tasks
VerifiedBuilds an overview of what is already running and proposes 3–5 further tasks from the board that can run in parallel with it, each with a suggested model and reasoning effort; the user picks tasks and models, and every picked task is started as its own linked Claude Code session; once all are done, their worktrees and local branches are cleaned up. Triggers on sentences like "was kann ich parallel angehen?", "gib mir die nächsten Aufgaben zum Parallelisieren", "Übersicht über mögliche nächste Aufgaben", "was können wir noch parallel starten?", "starte weitere Aufgaben in eigenen Sessions", "what can run in parallel?", "propose the next parallel tasks", "start more tasks in separate sessions". Only makes sense in this repository (snotra) and in the Claude desktop app, where sessions can be started.
Propose parallel tasks and start them as sessions
The user wants a short menu: what is running, and three to five more things that could run next to it. They decide; this session then starts the picked tasks, each in a session of its own, and stays free for the conversation.
Talk to the user in German (see language.md); the
briefs handed to the new sessions are English, like everything else in the
project.
Step 1 — what is already in flight (brief, without asking)
Collect in parallel, keep the output terse:
- Other sessions —
mcp__ccd_session_mgmt__list_sessions(not archived,limit30). Keep the ones that work in this repository and are running or waiting on the user; note title, branch and PR. Issue numbers in a title or branch (#1033,…-1033-…) mark that issue as taken. - Open pull requests —
gh pr list --repo kkrafft1999/snotra --state open --json number,title,headRefName,files. Thefilestell which areas are busy. - Worktrees and local state —
git worktree listandgit status --shortin the main checkout. Uncommitted work is in flight too. - The board, open issues only — never drop the
--query, seetask-management.md:
Thengh project item-list 2 --owner kkrafft1999 --query "is:issue is:open" \ --limit 200 --format jsongh issue list --repo kkrafft1999/snotra --state open --limit 100for open issues the board misses.
Read single issues (gh issue view <nr>) only for the candidates you are about
to propose — not the whole backlog.
Step 2 — choose 3–5 candidates
Order of preference: Ready first, then Backlog. Skip anything that is already taken (Step 1) or explicitly parked (a label, a comment such as "zurückgestellt", "wait for", "blocked by").
A candidate must be parallel-safe:
- No shared files with a running session, an open PR or another candidate.
Estimate the area from the issue text and a quick
grep/ls; when two candidates would both touch, say,src/renderer/chat/or the same rule file, keep only one. - No dependency on unmerged work or on another candidate.
- No release work (
releaseskill, version bump) and nothing under.github/workflows/— those serialise everything else. - Bounded: one session can finish it to a merged PR. An epic is not a candidate; one of its child issues may be.
If fewer than three parallel-safe tasks exist, propose fewer and say why. Never pad the list.
Step 3 — model and effort for each candidate
Suggest the cheapest setting that still solves the task reliably — when in doubt, one step up. A failed run costs more than the difference.
| Model (ID) | Use it for | Typical effort |
|---|---|---|
Haiku 5.5 (claude-haiku-5-5) | Mechanical, fully specified: regenerating screenshots, renaming, a label or wording fix, a dependency bump with green tests, read-only lookups. | low–medium |
Sonnet 5.5 (claude-sonnet-5-5) | A well-described feature or bug in one area with a clear repro or acceptance criteria; writing tests; translating a document (#281-style). | medium–high |
Opus 5.5 (claude-opus-5-5) | Cross-cutting changes, architecture findings (AR-xx), IPC/concurrency/timing, flaky tests without a known cause, sandbox and security, visible UI that has to meet ux-ui-standards.md. | high–xhigh |
Fable 5.1 (claude-fable-5-1) | Only the hardest, long-running pieces: a root cause across processes after earlier attempts failed, a redesign of the security concept. About 2.5× the price of Opus — name the reason. | high–xhigh |
max effort only when correctness clearly outweighs cost and xhigh has
already fallen short on this kind of task.
Limit of the app: start_session only accepts a model of the same family
or cheaper, and an effort at or below this session's own. Anything higher is
ignored at start. Check this session's model (system prompt) before
presenting: if a suggestion lies above it, mark it in the table and see Step 5.
Step 4 — present and let the user decide
First a short block "Läuft bereits": one line per running session or open PR (title, link, area). Then a table, numbered, one row per candidate:
| # | Aufgabe | Worum es geht / was es braucht | Bereich | Modell · Effort | Warum |
|---|---|---|---|---|---|
| 1 | #1234 Title | One sentence. | src/main/… | Sonnet 5.5 · medium | Half a sentence. |
Never bare issue numbers — title and one sentence each, so the user can pick without opening an issue.
Then ask with AskUserQuestion:
- Which tasks? —
multiSelect: true, one option per candidate, label#<nr> <short title>, description = model · effort. A question holds at most four options: with five candidates, split them over two questions ("Aufgaben 1–3", "Aufgaben 4–5"). - Model and effort? — "Wie vorgeschlagen (Recommended)" / "Einzeln anpassen".
On "Einzeln anpassen" ask once more, one question per picked task (four per
call, a second call for a fifth), each with up to four Modell · Effort
combinations: the suggestion first, marked (Recommended), then sensible
neighbours (one step cheaper, one step stronger, a different effort). The user
can type any other combination under Other.
Step 5 — start the sessions
For each picked task, in one message (call mcp__ccd_session__mark_chapter
first when starting two or more), write a bold title line and one sentence,
then call mcp__ccd_session__start_session:
-
initiation: "user_asked"— the user picked it, so it starts now. -
context: "fresh",use_worktree: true— the sessions run in parallel and must not share a checkout. -
name: short slug, e.g.i1234-tree-reopen. -
modelandeffortas decided. If the choice lies above this session's own model or effort, the app would silently drop it. Tell the user before starting and offer the two ways out: start it on this session's level, or have the user raise this planning session in the app's model picker and run the skill again. Do not start it and switch afterwards — the first turn, which does most of the work, would already run on the lower model. -
title:#<nr> <issue title>, under 60 characters. -
prompt— the brief, in English:Work on issue #<nr>: <title> — https://github.com/kkrafft1999/snotra/issues/<nr> Read the issue and its comments first. Scope: <what to change, which files/area>. Stay inside it; other sessions are working on <busy areas> in parallel — do not touch those files. Done means: <the issue's definition of done, or your own concrete list>. Then follow .claude/rules/git-workflow.md to the end: npm test and npm run test:e2e green, push, PR with "Closes #<nr>" and the user-manual box ticked (.claude/rules/user-manual.md), pipeline green, squash merge. Move the issue to "In progress" on board 2 when you start. Other worktrees run their tests at the same time and share node_modules: rerun once on ENOTEMPTY or a locked file before suspecting your change. Leave this worktree and branch in place after the merge; the planning session removes them. -
background(at least 80 characters): that this session was started by theparallel-tasksskill next to other sessions, which areas those sessions hold, and anything from the conversation that changes the task.
After the calls, one short German summary: which sessions run (linked as
[title](#local_<id>)), on which model and effort, and which tasks were not
started. Then stop — do not poll. When a session reports back, check its PR
before telling the user it is done.
Step 6 — clean up once all tasks are done
When the last session started in Step 5 has finished, the planning session tidies up locally — always, without being asked. "Finished" means: every session has stopped working, and its PR is merged or the task was abandoned. One that is still running or waiting on the user keeps its worktree; report it and clean up only the others.
For each finished session (list_sessions with linked: true gives branch
and cwd):
-
Merge confirmed —
gh pr view <nr> --json state,headRefOidsaysMERGED, andheadRefOidequals the local branch tip (git rev-parse <branch>). A squash merge leaves the branch unmerged in git's eyes, sogit branch -drefuses; this check is what makesgit branch -Dsafe. Different SHAs mean local commits that never reached the PR — stop and ask. -
Nothing unique left in the worktree — in this order, because
git statusrefreshes the index and hides its timestamp:- the timestamp of
.git/worktrees/<name>/index, read first; ls -A <worktree>/out—out/is gitignored, and builds, mockups and reports live there;git worktree removedeletes them without asking;git -C <worktree> status --porcelain— must be empty.
Anything found: name it to the user and leave that worktree in place.
- the timestamp of
-
Remove —
git worktree remove <worktree>, thengit branch -D <branch>. GitHub has already deleted the remote branch on merge (delete_branch_on_merge); never delete a remote branch by hand.
Then, in the main checkout: git worktree prune, git fetch --prune, and
git pull --ff-only on main, so the merged work is there locally.
Finish with one German line per task: PR merged, worktree and branch removed, or what was kept and why. Offer to archive the finished sessions — archive only on the user's yes.
Notes
- Parallel test runs from several worktrees share
node_modulesthrough the symlink. A one-offENOTEMPTYor a locked file is a collision, not necessarily a defect — that is why the brief asks for one rerun. - The skill proposes; it does not re-prioritise the board. Moving issues to Ready stays the user's call.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 467k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 319k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 319k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 319k | Updated | Claude CodeCodex | Verified | Install |