Parallel Coding Agents Are Rediscovering the Blackboard

Run enough Claude Code sessions in parallel and you'll hit the wall every multi-agent developer hits: the agents don't wreck each other's files anymore — worktrees solved that — they wreck each other's plans. One session merges to main while another is mid-push. You glance at a branch, decide it's stale, and delete it while a session three tabs over is actively building on it. Indie developer Dexter Lung described exactly that near-miss recently — a live branch rescued only by git reflog — and his fix is worth paying attention to, not because it's novel, but because it's fifty years old.

His solution: a single markdown file on mainline that every session reads and writes. Sections for in-progress, backlog, and done. An area map declaring which work touches which parts of the codebase. One hard rule — claim before you act: add your row, push immediately, and let git be the lock. First push wins; the loser pulls, sees the claim, and picks something else. He's published the template and scripts as agent-work-board under MIT.

The blackboard is back

If you took an AI course before deep learning ate the curriculum, you'll recognize this instantly. It's the blackboard architecture from CMU's Hearsay-II speech understanding project in the 1970s: independent "knowledge sources," each competent at one thing, watching a shared data structure and opportunistically contributing when they see something they can act on. No central scheduler micromanaging every step — coordination emerges from shared visible state.

That pattern spent decades as a historical footnote because we stopped building systems out of loosely coupled reasoning agents. Now everyone with a Claude Code subscription is building exactly that, and the coordination problem is back with the same shape it had in 1975. The revival isn't nostalgia; it's convergent evolution. When your workers are opaque, stateless-ish reasoners that can't share memory, a durable shared artifact they all read and write is the natural coordination primitive.

What's telling is the medium. Lung didn't build a lock server or a message queue. He used a markdown file versioned in git — and that's the correct engineering call, not a hack. Git already gives you the hard parts: atomic compare-and-swap (push rejection on a stale ref), full audit history, and conflict surfacing. Push-to-claim is optimistic concurrency control that every developer already understands. And a markdown file is legible to the one participant who matters most: you, three days later, trying to remember which of six sessions was doing what. Lung's sharpest observation is that the bottleneck was never agent throughput — it was his own attention across days of scattered sessions.

What the vendor gives you, and where it stops

Anthropic has been shipping into this space from two directions, and it's instructive where each stops short.

Git worktrees are the official answer to parallel sessions, and they work — each session gets its own checkout, so edits never physically collide. But worktrees are isolation, not coordination. Anthropic's own docs concede the limit: worktrees prevent sessions from overwriting each other's files, not from making incompatible assumptions. Two agents can each pass their tests in their own worktree and still produce a merge that's semantically broken. Isolation without shared intent just defers the collision to merge time.

Agent teams — experimental, off by default behind CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 — are the real coordination play: a lead session, teammates with their own context windows, inter-agent mailboxes, and a shared task list where claiming uses file locking to prevent races. That's a blackboard, just JSON under ~/.claude/teams/ instead of markdown on mainline. But it's scoped to one session and largely ephemeral: the team config is deleted when the session ends, in-process teammates don't survive /resume, and there's exactly one team per session. It coordinates a burst of parallel work, not a week of it.

That gap — durable, cross-session, cross-day coordination — is precisely where the markdown blackboard lives. It also happens to be tool-agnostic: the same file coordinates Claude Code, Cursor, and Codex sessions, which no vendor's team feature will ever prioritize.

Adopting it without fooling yourself

If you're running two or more concurrent sessions on one repo, the pattern costs almost nothing to try. Put a WORK-BOARD.md on mainline, define five to eight named areas of the codebase (areas, not files — file-level claims are too granular to survive contact with a refactor), and write the claim-before-act protocol into CLAUDE.md so every session ingests it at startup.

Then internalize the two failure modes Lung documents, because they're the honest part of the writeup. First, the board itself becomes the contention hotspot — the one file everyone writes needs the strictest rules, so each session edits only its own row. Second, and more damning for anything agent-maintained: the board lies. Sessions forget to update rows; claims go stale. His answer is a script (npm run board) that derives branch freshness from git history instead of trusting what agents wrote. That's the principle to steal even if you steal nothing else — derived state over declared state. An LLM following a protocol is soft enforcement; it holds until context runs long. For hard guarantees, back the convention with hooks or CI — and even there, Lung managed to accidentally neuter his own pre-push check by adding an always-succeeding reminder line to it. Governance that can't fail loudly isn't governance.

My read: this specific artifact is scaffolding with a shelf life. Claude Code's task lists already persist locally across resumed sessions; durable, project-scoped team state is an obvious next step for every agent vendor, and when it lands, hand-rolled boards will fade the way TODO.txt faded into issue trackers. But the architecture underneath — shared, durable, human-inspectable state as the coordination layer for opaque parallel workers — is the part that was true in 1975 and will still be true when the tooling catches up. Bet on the blackboard, not the board.