Przejdź do treści
Biblioteka skilli
AI i agenci · Automatyzacja

casa-parallel

/casa-parallel

Dzieli dużą, rozłączną pracę na niezależne części, wykonuje je równolegle i weryfikuje połączony wynik przed uznaniem zadania za gotowe.

Repozytorium
casa ↗
Licencja
MIT
Ostatnia zmiana repozytorium
14.09.2026

Ocena i bezpieczeństwo

90/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść25 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 14.09.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Dzieli dużą, rozłączną pracę na niezależne części, wykonuje je równolegle i weryfikuje połączony wynik przed uznaniem zadania za gotowe.

Oryginalny opis (EN)

Run a big task faster by splitting it into independent pieces and working them at the same time. Casa first checks the split is actually worth it, runs the pieces concurrently, then merges and verifies the combined result before calling it done. Use when a task is large and separable (a research sweep, a multi-file build, a multi-part audit, a content kit), or when the user says parallelize, fan out, split this up, or make this faster.

Jak działa

  1. Steps
  2. Notes
Sekcje z nagłówków SKILL.md, w oryginale · 71 linii, 588 słów
Podgląd SKILL.md
---
name: casa-parallel
description: Run a big task faster by splitting it into independent pieces and working them at the same time. Casa first checks the split is actually worth it, runs the pieces concurrently, then merges and verifies the combined result before calling it done. Use when a task is large and separable (a research sweep, a multi-file build, a multi-part audit, a content kit), or when the user says parallelize, fan out, split this up, or make this faster.
---

# casa-parallel

Speed through parallelism, but only when it actually pays. The benchmark behind this is
clear: fan-out wins 2-3x on big, even, independent work and loses on small or dependent
work. This skill makes the planner decide, then executes the plan.

The brain dir is `company-brain/`. All scripts live at `${CASA_ROOT:-${CLAUDE_PLUGIN_ROOT}}/scripts/`.

## Steps

0. If `company-brain/profile.json` does not exist, tell the founder to run /casa-start
   first and stop.

1. Decompose. Break the task into subtasks. For a playbook wave, the subtasks are the
   ready nodes (`node ${CASA_ROOT:-${CLAUDE_PLUGIN_ROOT}}/scripts/wave.mjs company-brain`). For an
   ad-hoc task, split it yourself into the smallest set of genuinely independent pieces,
   and for each estimate `effort` (rough minutes) and list `deps` (ids it must follow).

2. Ask the planner. Run:
   `node ${CASA_ROOT:-${CLAUDE_PLUGIN_ROOT}}/scripts/planner.mjs '[{"id":"a","effort":8},{"id":"b","effort":8,"deps":["a"]}]'`
   It returns `{ mode, waves, estSpeedup, width, warnings, reason }`.
   - If `mode` is `serial`, do the task normally in this session. Tell the user why
     (single task, dependency chain, chunks too small, or merge cost dominates). Stop here.
   - If a warning names an `imbalanced` chunk, split that chunk further and re-plan first.
     The slowest worker caps the whole wave, so balance matters more than width.

3. Fan out, wave by wave. For each wave in `waves` (in order, they are a barrier):
   spawn one subagent per subtask in that wave CONCURRENTLY (multiple Task tool calls in
   a single message). Give each subagent only its own slice plus any shared contract
   (interfaces, schema, house rules) so independent workers do not drift.
   - Before a worker starts, record it:
     `node ${CASA_ROOT:-${CLAUDE_PLUGIN_ROOT}}/scripts/ledger.mjs append company-brain '{"task":"<id>","dept":"<dept>","agent":"<agent>","status":"running"}'`
   - When it finishes, record the outcome with a PATH to its artifact (never the contents)
     and a one-line decision:
     `... append company-brain '{"task":"<id>","status":"done","artifact":"<path>","decision":"<one line>"}'`

3a. Respect the gates. If any subtask would spend money, publish, merge to main, or do
    something destructive (the `always_ask` line in `company-brain/dials.json`), do NOT
    let the worker do it. Record `{"task":"<id>","status":"blocked","note":"<what it needs>"}`
    and surface it to the founder for approval before proceeding.

4. Serialize the tail. Waves after the first run only once their dependencies are done.
   A dependent synthesis step (it consumes the front waves) is irreducibly serial; do it
   last, in this session, over the collected outputs.

5. Verify before done (the merge gate). Do not trust each worker's self-report.
   - Code: assemble the pieces and run the REAL suite over them, unmocked:
     `node ${CASA_ROOT:-${CLAUDE_PLUGIN_ROOT}}/scripts/verify.mjs <dir>`. A worker can pass its own
     mocked test while having drifted from the shared contract; only the integrated run
     catches that. If it fails, fix the drift (usually one module not importing the shared
     types) and re-run before declaring done.
   - Research / content: synthesize the wave outputs into one coherent result, resolving
     overlaps and contradictions.
   - Record the merge: `... append company-brain '{"task":"merge-verify","status":"merged","decision":"<verify result>"}'`

6. Report. Give the user the merged result and a one-line note of what ran in
   parallel, in plain words. Do not quote modeled or realized speedup numbers unless
   the founder asks. The full timeline is in the ledger
   (`node ${CASA_ROOT:-${CLAUDE_PLUGIN_ROOT}}/scripts/ledger.mjs status company-brain`).

## Notes

- This skill uses this session's own subagents (the path validated at ~2-3x on the Max
  subscription). The headless / multi-account path (more accounts raise the concurrency
  ceiling) is `scripts/dispatch.mjs` driven by the `scripts/headless-runner.mjs`
  `claude -p` runner. That path is ToS-gated (repo rule 5): it runs only on your own
  ANTHROPIC_API_KEY with CASA_OPERATE=1, never on a subscription.
- Keep ledger events thin: an `artifact` is a file path, not the file. Big content goes
  in the file, its path goes in the ledger.

Wersje

W bazie nie ma innych skilli o nazwie casa-parallel.

Migawka bazy z 13.11.2026 · wersja paczki 4b8579ae5573 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100parallel-work
    Dzieli prośbę na niezależne zadania, wykonuje je równolegle w osobnych sesjach i scala wyniki po potwierdzeniu.
  • 100parallel
    Dzieli zadanie na niezależne części, uruchamia podagentów i sprawdza ich wyniki, a sam pracuje nad główną ścieżką.
  • 90ultrawork-graph
    Dzieli dużą pracę na niezależne węzły wykonywane przez równoległe agenty i scala wyniki po weryfikacji każdego węzła.
  • 100dynamic-workflow
    Projektuje i orkiestruje dynamiczne workflow Claude Code, które rozdzielają pracę na 10 do 100 subagentów równolegle z weryfikacją: kiedy je stosować, wzorce fan-out i fan-in oraz bramki weryfikacji.
  • 100fork-join
    Uruchamia równolegle wielu wyspecjalizowanych subagentów i łączy ich wyniki w jeden rezultat, gdy zadanie da się podzielić na niezależne równoległe części.
  • 100parallel
    Rozdziela niezależne prace z rozłącznymi plikami i bez wspólnego stanu na subagentów, a potem zbiera wyniki i uzgadnia je we wspólnym zestawie testów.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.