CFLS: Collaborative File Lock Sync

Inspiration

We kept running into the same frustrating moment in shared repositories: two people would start changing the same part of the code without knowing the other person was already there. The problem becomes even easier to miss when AI coding agents are working alongside developers.

Usually, the conflict is discovered too late—during a merge, review, or release—when both people have already spent time on overlapping work. We wanted to create a small, calm signal that answers one question early enough to matter: “Is this file already in play?”

What it does

CFLS, or Collaborative File Lock Sync, is a real-time coordination layer for developers and AI coding agents working in the same Git repository.

It shows live editing presence, soft file locks, declared intent, and planned file creation so teammates can see what is already happening before they begin overlapping work. Instead of finding out about a collision after the work is finished, a developer or coding agent can coordinate, wait, or choose a safer task.

CFLS does not replace Git. It does not upload source code through its Host, and it does not try to become another code-hosting platform. Git still owns the code, commits, branches, pull requests, reviews, and final merge resolution. CFLS only helps teams avoid the conflicts that never needed to happen in the first place.

How we built it

We built CFLS as a TypeScript pnpm monorepo with a shared Coordination Host and a local CFLS Agent on every teammate’s computer.

The editor extension talks only to the local Agent. That Agent sends signed, repository-relative coordination metadata to a shared Host over WSS/TLS. The Host validates devices, gives events a consistent revision order, stores metadata in SQLite for the MVP, and broadcasts the shared state back to connected teammates.

The project includes a VS Code/Kiro extension, a local MCP surface for coding-agent integrations, a read-only Host dashboard, a CLI, and a three-person playground. The playground makes the idea easy to test: open Alice, Bob, and Carol’s generated workspaces, edit the same file in one window, and watch the coordination signal appear in the others.

Challenges we ran into

The difficult part was not adding a lock icon to a file. It was making the signal useful without making collaboration annoying or creating a second source of truth.

We had to be careful about what gets shared, how competing claims are ordered, and what happens when someone is offline. A stale coordination signal presented as current would be worse than no signal at all, so the Agent clearly marks cached state as stale instead of pretending the Host is still reachable.

We also chose an awareness-first model. CFLS starts with soft coordination signals rather than blocking developers by default. Teams can adopt stricter policies for sensitive paths, but CFLS does not pretend to be an operating-system file lock.

What we learned

We learned that many merge conflicts are really communication problems that Git only discovers at the end. A small amount of trustworthy context—who is active, what they intend to change, and what files are at risk—can prevent duplicate work before it starts.

We also learned that privacy and clarity matter as much as the protocol. CFLS shares operational metadata, not source contents, but that metadata still needs to be handled carefully.

How we used Codex and GPT-5.6

We used Codex with GPT-5.6 as a coding partner throughout the build: breaking the architecture into testable tasks, reviewing protocol and integration paths, designing the dashboard and landing page, and improving the documentation.

The product decisions, validation, and final checks remained human-led. We used the automated test suite and the live multi-agent playground to verify the implementation.

What's next

Next, we want to turn the strongest parts of the architecture into smoother everyday workflows: a packaged always-on Agent, a more polished dependency-aware experience, and stronger protected-path workflows for teams that need them.

The core boundary will stay the same: CFLS coordinates metadata, while Git remains responsible for source code and final merges.