Can Companies Stop Developers Reusing Code? A Legal Guide

INTRODUCTION 

Software development is a profession built on reuse. Developers carry skills, design patterns, and coding techniques from one project to the next — this cumulative expertise is what makes experienced programmers valuable. But when a developer changes employers or finishes a project for a client, a fundamental legal question arises: who actually owns the code that was written, and can the company stop the developer from using any part of it again?

This tension between a company's interest in protecting proprietary software and a developer's interest in leveraging their own technical knowledge plays out constantly — in employment contracts, in courtrooms, and in open-source communities. In most cases, the answer sits within a web of intellectual property law, contract provisions, and employment doctrines that firmly — but not unconditionally — favour the employer.

Copyright Law and Software Ownership

At the core of code ownership is copyright law. In the United States, software code is treated as a creative work and is automatically protected by copyright the moment it is written, in the same way as a novel or a musical composition. The Copyright Act grants several exclusive rights to copyright holders, including the rights to reproduce a work, distribute it, create derivative modifications, and display it. A developer who writes code independently, without any employment or contractual ties, retains full ownership and may use it as they wish.

Most professional developers, however, don't write code in a vacuum — they write it within the scope of employment or under a contract, which changes the ownership picture entirely. Copyright law recognises that the creator isn't automatically the owner of their creation, and the doctrine of "work made for hire" is the primary legal mechanism that shifts ownership to companies.

The Work-for-Hire Doctrine

The work-for-hire doctrine is arguably the most consequential legal principle governing code ownership. Under the U.S. Copyright Act of 1976, Section 101, a "work made for hire" is created either when an employee produces the work within the scope of their employment or when an independent contractor creates it under a special commission and both parties have signed a written work-for-hire agreement.

For full-time employees, the implications are straightforward: code written during work hours, using company resources, in pursuit of company objectives, must generally be transferred to the employer. The developer cannot retain a copy, reuse it at a new job, or claim authorship for licensing purposes — the employing company is treated as the legal "author" and can prevent the developer from reusing that code elsewhere.

Independent contractors sit in a different position. Contractors generally retain copyright over the code they develop, unless a written contract specifically transfers ownership to the client. This is precisely why companies routinely include IP assignment clauses in freelance and contractor agreements — without one, ownership does not automatically pass to the client on payment alone.

Contractual Restrictions: NDAs and IP Assignment Clauses

Companies use contractual tools beyond the work-for-hire doctrine to prevent code reuse – most commonly Non-Disclosure Agreements (NDAs) and IP assignment clauses.

NDAs bind developers to protect confidential company information from disclosure or unauthorised use — covering trade secrets, algorithms, database architectures, and other technical material that provides a competitive advantage. Courts generally enforce NDAs provided they are reasonable in scope, clearly define what counts as confidential, and don't function as disguised non-compete agreements that effectively bar a developer from working in their field at all.

IP assignment clauses go further than NDAs. They can allow an employer to claim ownership over intellectual property a developer creates during their employment – including work done on personal devices outside official work hours. Courts have scrutinised the broadest of these clauses for overreach. Several states, including California and Minnesota – among others with similar statutes – have enacted laws preventing employers from claiming ownership of inventions employees develop entirely on their own time, without company resources, and unrelated to their work for the employer.

Non-Compete Clauses and Their Evolving Legal Status

Non-compete clauses impose more severe restrictions, barring a departing employee from joining a competitor or starting a competing business for a defined period. In practice, they have often been used to prevent developers from bringing any technical knowledge or approach to a rival employer.

The legal landscape here has shifted significantly and is now materially different from where it stood in 2024. The FTC finalised a rule in April 2024 that would have banned nearly all non-compete clauses nationwide. It never took effect: a federal district court in Texas vacated the rule in August 2024, finding the FTC lacked statutory authority to issue it. The FTC initially appealed, but in September 2025 the Commission voted to abandon that appeal and formally accede to the vacatur — and the rule was removed from the Code of Federal Regulations altogether, effective February 12, 2026.

The practical result: non-compete enforceability has reverted entirely to state law, which varies widely. California continues to enforce Business and Professions Code Section 16600, which voids nearly all non-compete agreements outright. Other states — including Texas, Florida, and Georgia — continue to enforce reasonable non-competes under state law. The FTC has signalled it will still pursue case-by-case enforcement against non-competes it considers unfair or anticompetitive under Section 5 of the FTC Act, even without the broader rule in place.

Courts across jurisdictions have continued to uphold trade secret protections and NDA enforcement as legitimate tools for employers, even as the broader non-compete landscape has become more fragmented and state-dependent.

Open-Source Licenses and Their Intersection with Company Restrictions

A frequently overlooked dimension of code reuse involves open-source licensing. Many developers incorporate third-party open-source libraries into code they build for employers. Certain licences — such as the GNU General Public Licence (GPL) — impose "copyleft" conditions, meaning software incorporating GPL-licensed code may itself need to be released under the same licence if distributed.

This creates real tension for companies wanting to keep proprietary code private: if a developer uses a copyleft library in an employer's codebase and the employer distributes the product, the company may be unintentionally obligated to release portions of its source code publicly. Conversely, a developer who wants to reuse code from a previous employer's project in an open-source context may run directly into that employer's NDA or IP assignment clause — regardless of what open-source licence they intend to apply.

Developer Rights and Protections

The legal system gives companies real power to limit code reuse through IP rights, but developers aren't without protection.

First, no company can claim ownership over general programming knowledge, industry know-how, or widely understood coding techniques. Copyright protects specific creative expression — a particular implementation of a feature — not the underlying skill or concept. A developer who leaves an employer keeps their ability to write a login function, design a database, or implement an algorithm they've learnt professionally.

Second, state-level statutes in jurisdictions such as California, Washington, and Delaware provide explicit protection for inventions developed on personal time, without company resources. Developers who keep clear documentation of their personal project timelines and methods strengthen their position in any ownership dispute.

Third, courts increasingly reject overly broad NDAs or IP assignment clauses that attempt to claim ownership of everything a developer creates, including personal projects with no connection to their employer. The prevailing legal standard in most jurisdictions requires IP restrictions to be proportionate to legitimate business interests.

Conclusion

Companies do have powerful legal tools to restrict developers from reusing code — the work-for-hire doctrine, NDA provisions, and IP assignment clauses embedded in employment contracts are all widely exercised. U.S. law structurally favours employers when code is written within the scope of employment or under an explicit written assignment of rights.

These restrictions, however, are not limitless. Developers retain rights over their general expertise, independently developed tools, and personal projects created without company involvement. And the regulatory picture is more mixed than a simple trend toward developer autonomy: the FTC's attempt at a nationwide non-compete ban has now been fully abandoned, leaving enforceability to a patchwork of state law—even as several states continue to strengthen protections for employee-developed inventions.

The most practical guidance for developers remains contractual clarity before any work begins: understanding exactly what an employer is claiming through an IP assignment clause, negotiating carve-outs for personal projects, and keeping clear records of independently developed code are essential safeguards in a legal landscape that remains firmly tilted toward those who issue the paychecks.

Key Takeaways

• Software code is automatically copyright-protected the moment it's written — but ownership shifts to the employer for work created within the scope of employment.

• The work-for-hire doctrine gives employers legal "authorship" over employee-created code; independent contractors retain copyright unless a written assignment says otherwise.

• NDAs and IP assignment clauses are the main contractual tools companies use to restrict code reuse beyond copyright law itself.

• The FTC's 2024 nationwide non-compete ban never took effect, was vacated in court, and was formally abandoned by the FTC in 2025 — non-compete enforceability now depends entirely on state law.

• California continues to void nearly all non-competes under Business and Professions Code § 16600.

• Several states (California, Washington, Minnesota, and others) protect inventions developers create on personal time with no company resources.

• Developers retain rights to general programming knowledge and skill — copyright protects specific expression, not underlying technique.

Frequently Asked Questions

1. Who owns code a developer writes as a full-time employee?
Generally, the employer, under the work-for-hire doctrine, provided that the code was created within the scope of employment.

2. Do independent contractors automatically lose ownership of their code?
No — contractors retain copyright unless a written contract specifically assigns ownership to the client.

3. Can an employer claim code a developer writes on personal time and equipment?
Not in states with employee-invention statutes (e.g., California, Washington, Minnesota), provided the work is unrelated to the employee's job and doesn't use company resources.

4. Is the FTC's non-compete ban still in effect?
No. It was vacated by a federal court in August 2024, and the FTC formally abandoned its appeal and acceded to the vacatur in September 2024. The rule never took effect and has since been removed from federal regulations.

5. Does that mean non-competes are unenforceable everywhere now?
No — enforceability now depends entirely on state law, which varies significantly (e.g., largely unenforceable in California but more enforceable in states like Texas or Florida).

6. Can an NDA function as a disguised non-compete?
Courts generally won't enforce an NDA that's so broad it effectively prevents someone from working in their field at all.

7. Does copyright protect general programming skills or techniques?
No — copyright protects specific creative expression (a particular implementation), not general knowledge, concepts, or techniques.

8. What happens if a developer uses GPL-licensed code in an employer's product?
If the product is distributed, the employer may be obligated to release portions of its own source code under the same copyleft license.

9. Can a developer reuse open-source code from a former employer's project?
Only if it doesn't conflict with the former employer's NDA or IP assignment clause — the open-source license itself doesn't override those contractual restrictions.

10. What should a developer check before signing an IP assignment clause?
Its scope — specifically whether it attempts to claim ownership of work done outside employment hours, on personal equipment, and unrelated to the employer's business.

11. Are overly broad IP assignment clauses enforceable?
Courts increasingly reject clauses that try to claim everything a developer creates, including unrelated personal projects; enforceability generally requires proportionality to legitimate business interests.

12. Does the Copyright Act automatically protect code the moment it's written?
Yes, copyright protection is automatic upon creation, without registration, similar to other creative works.

13. What's the difference between a work-for-hire employee and a contractor under copyright law?
An employee's work-scope creations automatically belong to the employer; a contractor's creations belong to the contractor unless a written work-for-hire agreement says otherwise.

14. Is trade secret protection still enforceable after the FTC's non-compete rule was vacated?
Yes — courts continue to uphold NDA enforcement and trade secret protections as legitimate tools independent of non-compete law.

15. What documentation helps a developer defend ownership of a personal project?
Clear records of development timelines, methods used, and evidence that the work was done without company resources or during personal time.

© 2025. All rights reserved.