Insights · March 2026
Parallel work exposed which handoffs fail first.
Session 19 ran concurrent assignments through a shared repository. It tested ownership, dependency handling, review states, and file verification under the same rules I use for client delivery.
The stakes
Parallel output is useless when ownership breaks.
Concurrent tasks only help when each worker knows what it owns, what it needs, and what must be checked before review. I designed the exercise to pressure those handoffs.
The test
One shared repository, several dependent assignments.
Some assignments could proceed independently. Others needed files from earlier work. The test followed each task from assignment through verification and review.
01
Assign
Each task names its owner and checkout before work begins.
02
Build
Independent work proceeds while dependent work waits for its required inputs.
03
Verify
Files and build output must exist before a task moves to review.
04
Review
One run identifier keeps related actions and handoffs together.
What held up
Clear ownership kept parallel work from colliding.
Three controls carried the test: task ownership, one history for related actions, and file verification before review.
- Ownership
- Scoped tasks stayed separate when ownership and checkout rules were followed.
- History
- One run identifier kept related actions together when several updates landed in the same window.
- Review
- File verification and build output stopped incomplete handoffs before review.
What changed
Missing inputs need an explicit blocked state.
The weakest point was the handoff. Upstream files did not always reach the shared workspace, so dependent work stopped. The next change is stricter blocked-state handling and explicit handoff paths.
Client takeaway
Speed matters only when review means something.
Parallel delivery needs named ownership, visible dependencies, file verification, and a build check before review. That discipline carries directly into client work.