Isolating Residual Equitable Claims When Rebuilding Proprietary Code bases
Rebuilding proprietary code bases requires rigorous clean-room separation and verifiable audit records to isolate the new software from equitable claims.

Seat

Unwritten Contributions in Abandoned Repositories
A software architect builds an initial system alone on nights and weekends after an informal conversation with an operator regarding future equity. No corporate entity exists at the time, and no independent contractor or IP assignment agreement defines ownership of the code. Two years later, after commercial interest takes off, the operator incorporates a new company with fresh investors and hires an engineering team to rebuild the system from scratch.
The original developer holds no equity, no formal title, and an unwritten expectation of a half share based on an early conversation over coffee.
Memory adapts to fit current interests. An engineer who wrote the original parser views that code as the technical foundation of the commercial platform. The operator who commissioned the rewrite views the initial repository as a rough prototype discarded before commercial development began.
Without a formal assignment agreement, these conflicting accounts leave the rewritten system open to equitable claims of trade secret misappropriation, copyright infringement, and unjust enrichment.
An oral promise carries no immediate cost to state, but creates financial exposure for whoever relies on it without a written agreement.
Equitable doctrine fills gaps where formal contracts are absent. Quantum meruit allows recovery for services rendered without a governing agreement, while constructive trusts can attach to assets acquired through a breach of confidence. When developers who collaborated on an early codebase attempt an undocumented rewrite, establishing a clean chain of title becomes difficult.
Claims often center on structural design, database schemata, and core logic carried over from the original repository into the second codebase.
The underlying claim rests on whether the original architecture established the technical feasibility and market viability that allowed the company to form.

Weight

Architectural Lineage and Clean Room Separation
Demonstrating that a rewritten codebase carries no equitable encumbrances requires strict evidentiary isolation. Clean room engineering separates the specification process from implementation. One team analyzes the original system to write functional specifications without touching source code, while a second, isolated team receives those specs to write new code.
The development team has no contact with the original author. If founders attempt an internal rewrite without strict isolation, the clean room defense fails under forensic audit.
Engineers naturally repeat structural patterns they have built before. A developer rewriting a data pipeline will tend to reuse the same indexing strategies, concurrency primitives, and relational layouts. In copyright litigation, expert testimony often focuses on non-literal copying using abstraction-filtration-comparison tests.
Even when variable names are completely changed, structural alignment can indicate derivation.
| Isolation Model | Personnel Separation Criteria | Evidentiary Record Retained | Residual Exposure Level |
|---|---|---|---|
| Informal Rewrite | Original developers reconstruct modules from personal memory without isolation | Version control commit history showing rapid, unannotated feature generation | Substantial equitable claims under unjust enrichment and trade secret leakage |
| Specification Bridge | Initial authors document external functional requirements; separate engineers build code | Interface specification documents, audit trails of communication, sanitized schemas | Moderate exposure regarding non-literal structural derivation and trade secret misappropriation |
| Full Clean Room | Total physical and operational segregation between specification team and development team | Cryptographic timestamps, verified access logs, complete development diaries, recorded interviews | Low exposure, isolating claims to statutory patent challenges or novel trade secrets |
The burden of proof falls on the company defending the rewritten codebase to demonstrate independent creation. Commits lacking documented provenance draw scrutiny. Rushing a rebuild to bypass an unpapered collaborator often creates an evidentiary gap that invites equitable claims.
Clear equity terms must be executed early, or claims settled through formal release agreements.

Proof

Where Does the Burden of Independent Creation Shift?
Once a claimant establishes access and substantial similarity, the burden shifts to the company to prove independent creation. Access is straightforward to establish if members of the rewrite team had prior access to the original repository. Similarity goes beyond verbatim code; automated analysis tools highlight matching control flows, unique mathematical constants, shared commenting habits, and identical error-handling routines.
Shared bugs across both codebases strongly indicate derivation.
Rewriting code during active litigation or negotiations subjects the development process to immediate evidentiary scrutiny, requiring meticulous documentation at every stage.
- Functional specification isolation requires sanitizing functional specifications to remove proprietary structural markers before developers review the documents.
- Cryptographic timestamping verifies intermediate drafts, specifications, and pull requests to prevent allegations of backdating.
- Hardware sanitation records document that developers work on clean, factory-imaged machines with no access to legacy repositories.
- Independent third-party code review confirms that syntactic structures contain no legacy proprietary dependencies prior to deployment.
Recollection of software design persists in memory. An engineer who designed an asynchronous message queue retains memory of its edge cases and timing dependencies. Rebuilding the component without opening the original files does not sever that architectural lineage.
Courts examine whether proprietary trade secrets remained in the engineer’s memory and if applying that knowledge compromised the independence of the rewrite.
A signed release agreement resolves equity claims more reliably than a code rewrite.
The cost of defending against non-literal copyright infringement and ownership claims often exceeds the valuation of an early-stage company. Institutional investors review source code provenance during due diligence, and unresolved claims from a former contributor can halt funding or acquisition deals.
Unresolved equity disputes risk court-ordered constructive trusts over company shares or preliminary injunctions halting software distribution.

Yard

Dissolving Unfounded Arrangements and Moving Forward
Informal expectations of equal ownership carry no legal weight without formal corporate formation, stock issuance approvals, or written vesting schedules. Writing code for an early version does not grant ownership over subsequent platforms unless explicit contracts or IP assignments cover the transition. Enforceable rights depend entirely on written documentation.
Rebuilding software to avoid an equitable claim carries significant costs. Development timelines extend, and capital is spent on duplicate engineering effort. Meanwhile, exposure remains so long as the original developer holds a viable claim to the underlying architecture or trade secrets.
Unwritten recollection tends to expand claims of ownership, whereas written documentation restricts remedies to verified terms.
Resolving these disputes requires definitive action. A company can execute a retroactive assignment and release agreement backed by financial consideration, securing a full release of claims from the original developer. Alternatively, it can undertake a fully supervised clean room rebuild that documents every departure from the original codebase.
Separating a new codebase from its origins remains difficult when core architectural decisions stem from undocumented early collaborations.