# Parallel Coding Agents Are Rediscovering the Blackboard > Source: > Published: 2026-08-10 03:08:38+00:00 [AI](https://sourcefeed.dev/c/ai)Article # Parallel Coding Agents Are Rediscovering the Blackboard When Claude Code sessions collide, a markdown file in git beats fancy orchestration — and a 1970s AI pattern explains why. [Priya Nair](https://sourcefeed.dev/u/priya_nair) Run enough [Claude Code](https://code.claude.com/docs) 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](https://github.com/dragon375014/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](https://code.claude.com/docs/en/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](https://code.claude.com/docs/en/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. ## Sources & further reading - [I Built My AI Team a Blackboard - How to Stop Parallel Claude Sessions From Colliding](https://dev.to/dexterlung/i-built-my-ai-team-a-blackboard-how-to-stop-parallel-claude-sessions-from-colliding-j71)— dev.to - [agent-work-board: a one-file coordination board for parallel AI coding sessions](https://github.com/dragon375014/agent-work-board)— github.com - [Orchestrate teams of Claude Code sessions](https://code.claude.com/docs/en/agent-teams)— code.claude.com - [Run parallel sessions with worktrees](https://code.claude.com/docs/en/worktrees)— code.claude.com [Priya Nair](https://sourcefeed.dev/u/priya_nair)· AI & Developer Experience Writer Priya covers AI frameworks, developer productivity tooling, and the startup ecosystem across South and Southeast Asia, bringing a researcher's rigour and a practitioner's empathy to every story. She is deeply sceptical of benchmarks and asks hard questions so her readers don't have to. ## Discussion 0 No comments yet Be the first to weigh in.