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

concurrent-change

/concurrent-change

Ocenia, czy pracę warto podzielić między wielu agentów, i wskazuje, które części mogą iść równolegle, a które muszą się uzgadniać.

Repozytorium
terma ↗
Licencja
CC-BY-SA-4.0
Ostatnia zmiana repozytorium
27.10.2026

Ocena i bezpieczeństwo

100/ 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ść35 / 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 27.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

CC-BY-SA-4.0, otwarta.

Co robi i kiedy

Ocenia, czy pracę warto podzielić między wielu agentów, i wskazuje, które części mogą iść równolegle, a które muszą się uzgadniać.

Oryginalny opis (EN)

Use when work is about to be split across multiple agents, or when deciding whether it should be. Concurrency is a property of the change, not a scheduling decision — what can proceed at once is determined by what the pieces have to agree on. Trigger on any request to parallelise, fan out, delegate to subagents, or run work concurrently, and whenever a plan has more than one independent-looking piece. Do NOT use for single-threaded work, or for splitting purely to appear fast.

Jak działa

  1. The unit is the contract, not the file
  2. What is actually parallel
  3. Sizing
  4. Merging
  5. The default
  6. Shape
  7. Failure modes
Sekcje z nagłówków SKILL.md, w oryginale · 98 linii, 1 055 słów
Podgląd SKILL.md
---
name: concurrent-change
description: Use when work is about to be split across multiple agents, or when deciding whether it should be. Concurrency is a property of the change, not a scheduling decision — what can proceed at once is determined by what the pieces have to agree on. Trigger on any request to parallelise, fan out, delegate to subagents, or run work concurrently, and whenever a plan has more than one independent-looking piece. Do NOT use for single-threaded work, or for splitting purely to appear fast.
---

# Concurrent Change

Parallelism is not decided. It is discovered — by finding what the pieces of a change must agree on, and noticing which of them already do.

Two agents can work at once when nothing either produces changes what the other assumes. That is the whole condition. It is a fact about the change, and no amount of instruction, file-locking, or careful sequencing in the prompt can create it where it does not hold.

One operation: **find the agreements the work depends on, establish them first, then fan out over what remains.**

## The unit is the contract, not the file

The instinct is to split by file or directory, because those look separable. They are not the boundary. Two agents editing different files collide the moment they must agree on a name, a shape, a rule, or an error case — and they will resolve that disagreement differently, in isolation, each locally correct.

The real boundary is the contract: the types, signatures, invariants, and vocabulary the pieces share. Work is concurrent when the contract between the pieces is already fixed.

This gives the sequence, and it is almost always the same:

**Establish the contract in one place, alone. Then fan out over the implementations.**

Types, module boundaries, error cases, the names of things — these are what everything downstream reads. Written once, sequentially, they cost little. Discovered independently by four agents, they produce four dialects and a merge that has to pick a winner and rewrite the losers.

The contract is not a design document. It is the actual thing — the type definitions, the signatures, the empty modules — committed and readable, so each agent reads the same source rather than a description of it.

## What is actually parallel

After the contract exists, ask of each pair of pieces: *if both are done at the same time, does either invalidate what the other assumed?*

Genuinely concurrent — the shared thing is fixed and only read:
- implementations behind an already-written interface
- independent leaves: one per adapter, per platform, per endpoint, per case of a settled enum
- reading and investigating anything, always — there is nothing to collide

Not concurrent, however it is arranged:
- anything that may rename, re-shape, or re-scope the shared vocabulary
- two pieces that must arrive at a consistent answer to a question neither has been given
- work whose *findings* redirect the other work — the second agent proceeds on a premise the first is in the process of destroying

That last one is the expensive mistake. Investigation fans out well; acting on unfinished investigation does not.

## Sizing

A piece worth giving to an agent is one that can be stated in a few lines, carries its own means of verification, and returns something small enough to be read.

Too small and the overhead of stating it exceeds doing it. Too large and it makes contract-level decisions on its own — which is the split failing, silently, in a way that only shows at merge.

The signal for "too large": the piece cannot be described without describing how it should be built. That means the design is still open, and it belongs in the contract phase, sequential.

Each piece needs its own check, run inside the piece. An agent that cannot tell whether its own work landed returns a claim, and claims must be re-verified centrally — which serialises the thing that was parallelised.

## Merging

Plan the merge before the fan-out, because it decides the split.

What comes back should be small: what changed, what was verified and how, what was assumed. Not a narrative. If the returns have to be read in full to be integrated, the split was wrong — too much was left open.

The join is where contract violations surface. Two pieces that each verified fine can still contradict each other, and nothing in either piece can see it. Check the shared surface explicitly after the join: does it still say one thing?

Merge conflicts in text are the cheap case — a tool reports them. The expensive case is two pieces that merge cleanly and now disagree in meaning.

## The default

Most work is not parallel, and running it concurrently makes it slower and worse.

Sequential is right when the work is one coherent change, when each piece teaches something the next needs, when the design is still moving, or when the total is small enough that coordination costs more than the work. A single agent holding the whole change in view produces something consistent; four produce something assembled.

Fan out when the pieces are genuinely independent, numerous enough to matter, and each large enough to be worth stating. Three or more real leaves behind a fixed contract is the case that pays.

## Shape

```
Change: five storage backends behind one interface.

Sequential first — this is the contract, and everything reads it:
  Store trait, error cases, the round-trip property test.
  Nothing else starts until this is committed.

Then concurrent — five pieces, each reads the trait, none writes it:
  one agent per backend. Each returns: passing/failing round-trip
  property, plus anything it could not satisfy.

Not concurrent: the trait itself. If any backend cannot satisfy it,
  the trait is wrong — that comes back to the middle, sequentially,
  and re-fans. Expect this once.

Join: run the property suite across all five together. Two backends
  passing alone can still disagree about what an empty key means.
```

## Failure modes

- **Splitting by file.** Directories look independent and are not. The contract is the boundary.
- **Fanning out before the contract exists.** Each agent invents the missing vocabulary. Merge picks one and rewrites three.
- **Parallel investigation into parallel action.** Fine to look at once; not to act on what is still being looked at.
- **Unverifiable pieces.** Agents that return claims rather than checked results push all verification to the join.
- **Coordination in prose.** "Don't touch the shared types" is not a mechanism. If two pieces can both change something, eventually both will.
- **Splitting for appearance.** Fan-out on work that was three sequential steps costs more and returns something less coherent.
- **Silent re-fan.** A backend that cannot meet the contract is information about the contract. Not something to work around locally.

Wersje

W bazie nie ma innych skilli o nazwie concurrent-change.

Migawka bazy z 13.11.2026 · wersja paczki 3113642a249c (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

  • 100dev-team
    Uruchamia równolegle wielu agentów inżynierskich do pracy wymagającej dużego kontekstu, gdy zadanie da się podzielić na niezależne strumienie.
  • 100parallel-agent-work
    Decyduje, czy podzielić pracę między podagentów, i bezpiecznie prowadzi podział z izolacją gałęzi.
  • 100parallel-agents
    Ocenia, czy jednostki pracy mogą iść równolegle przez agentów: niezależność, izolacja zmiennego stanu, szerokość fali i uzgadnianie wyników przed integracją, przy śledztwach, przeglądach i zadaniach planu.
  • 100parallel-agents
    Podaje wzorce orkiestracji wielu agentów, gdy niezależne zadania mogą iść równolegle z różną wiedzą dziedzinową albo potrzebna jest analiza z wielu perspektyw.
  • 100parallel-agents
    Podaje wzorce orkiestracji wielu agentów, gdy niezależne zadania mogą iść równolegle z różną wiedzą dziedzinową albo potrzebna jest analiza z wielu perspektyw.
  • 90casa-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.

Uwagi i zgłoszenia

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