What happened
On October 27, 2026, Delta announced that Claude Code work can now be shared with a teammate in beta. The feature is delivered through the Delta CLI and a Claude Code plugin. Its basic workflow is command-driven: a developer runs /delta share in Claude Code, receives a link, and sends that link to a teammate. The teammate joins from their own Claude Code session with /delta join <link>.
The shared unit is more than a repository diff. Delta says the plugin shares the Claude Code conversation and the worktree. This means the joining developer can inspect what the original developer and agent have tried, ask questions, and contribute while changes remain unfinished. Delta describes this as an alternative to waiting for a commit or creating a pasted summary. It is explicitly aimed at work handoffs that occur before a task is ready to become a pull request.
The file layer and the agent layer have separate roles in Delta's description. The Delta CLI keeps files synchronized across machines. The shared conversation is available as context, while each participant continues to use their own Claude session. In other words, the announcement does not describe multiple people literally operating a single Claude account or session; it describes individual Claude sessions connected to a shared thread and synchronized worktree.
Delta also positions the feature as cross-tool collaboration. A developer already working in Delta can bring colleagues who prefer Claude Code into the same thread, while each person remains in their chosen environment. The company says this supports teams operating across time zones, where one person can stop working and another can pick up the thread later. The immediate supported path is Claude Code, but Delta says it is building support for more harnesses, starting with Pi.
The Claude Code plugin is open source and is presented as a reference implementation for connecting another preferred harness. Delta points prospective contributors to a guide for building their own plugin. The announcement does not specify a general availability date, supported operating systems, synchronization conflict behavior, or the terms of any paid Delta plan that may apply. The product page labels the feature beta.
What the archive adds
Our archive contains an earlier Telegram post about running parallel Claude Code agents through Git worktrees, emphasizing isolation, artifacts, and verification. This is a new fact on that working pattern: rather than only isolating parallel work, Delta adds a mechanism to transfer an unfinished worktree and its agent conversation between people. The Field Note archive has no earlier published note genuinely covering Delta's collaboration feature.
Trend signal
This supports Harness architecture outlives model choice. Delta is presenting collaboration state—conversation, worktree, file synchronization, and cross-harness connection—as the durable layer around a coding agent. The feature preserves use of Claude Code rather than requiring every collaborator to adopt one interface, while its open-source plugin is a reference path for additional harnesses.
Why now
Delta frames the release around a current team problem: developers are choosing different agents and tools, while distributed teams need to hand work across time zones. The announcement argues that a commit or diff alone omits the reasoning and failed attempts that matter when an agent-assisted task is still in progress. The beta arrives as an attempt to make that intermediate state shareable.
Connections to other events
The archive's earlier worktree coverage treated isolation as a prerequisite for parallel coding agents: separate worktrees reduce interference, while issues and pull requests provide operational boundaries. Delta addresses a neighboring problem rather than replacing that structure. It offers continuity when ownership changes before the work reaches the pull-request boundary, carrying the conversation alongside the isolated files.
Why it matters
For teams using Claude Code, the costly failure mode is often not producing a first draft of code but reconstructing why the agent changed files, what approaches were rejected, and what remains unsafe to merge. A shared thread can reduce that reconstruction work when a reviewer, pair, or next-shift developer joins mid-task.
The practical consequence is that teams can treat an in-progress agent run as a collaborative artifact, not merely a local terminal interaction. That may make earlier human intervention possible: a teammate can inspect the state before a questionable branch becomes a polished pull request. It also creates a new process decision. Teams will need to decide when a live shared session is appropriate, who is accountable for changes, and when the work should still be converted into ordinary reviewed commits and pull requests.
What happens next
- Delta adds at least one further harness integration beyond Claude Code. (6 months, 65%). Watch for: a released Pi integration or another documented plugin.
- Teams test live session handoffs for distributed or paired coding work. (3 months, 60%). Watch for: Delta guidance on collaboration workflows, controls, or operational practices.
Limits and uncertainty
This is a vendor announcement about a beta, not an independent evaluation of reliability or team outcomes. The source does not quantify latency, synchronization behavior during concurrent edits, failure recovery, permission controls, data retention, or security boundaries for shared conversations and worktrees. It also does not say whether the feature works with every Claude Code configuration, what Delta account requirements apply, or how it handles secrets that may already be present in a local worktree. The open-source plugin establishes a reference implementation, but the announcement does not establish interoperability with any specific non-Claude harness.
Skill to build now
Run a small handoff drill this week: begin a bounded Claude Code task, leave it uncommitted, and have a teammate join through Delta. Ask the second developer to identify the task goal, the most important attempted approach, and the next verification step using only the shared thread and worktree. Then compare that result with a handoff based on a diff and a written summary. Record which context was necessary and which information should still be captured in commits, tests, or the pull request.
Reader takeaway
Delta's beta makes the pre-commit state of Claude Code work shareable: another developer can join with both the agent conversation and the unfinished worktree. That is a meaningful operational addition for teams whose agent-assisted tasks routinely outlive one developer's uninterrupted session, but it still needs normal code review and verification boundaries.
Open question
Can shared worktrees and conversation context remain safe and understandable when several contributors make edits at once, particularly where repository credentials or sensitive local files are present?