Operations
Who Owns the Code When You Hire a Software Firm?
Quick Answer
Paying for custom software does not transfer ownership by default, because copyright starts with the author and moves to the buyer only through a written assignment. Real ownership has three layers, which are legal ownership of the foreground code, operational ownership that lets another team take over within two weeks, and provable ownership with a clean human authorship trail, which matters more when AI helped write the code.
Who owns the code when you hire a software firm? By default, the person or company that creates the code owns it, not the person who pays for it. We start here because the answer rarely matches what founders expect. If you hire a software development company, ownership does not transfer automatically just because money changed hands. It must be assigned in writing, and in 2026 that is only the first layer of the answer.
The practical test is bigger than copyright language. Real ownership has three layers:
- Legal ownership. Who holds the copyright and related IP rights?
- Operational ownership. Can another competent team take the repo, docs, tests, CI/CD, and accounts and ship a change in two weeks?
- Provable ownership. Can you show a clean authorship trail, especially when AI helped generate parts of the code?
If one of those layers is missing, you may own the code on paper and still be locked out in practice.
Why the Person Who Paid Does Not Own the Code by Default
We see this surprise founders often, because software ownership follows authorship first, not payment first. That is the default assumption in copyright law and in most vendor relationships. A founder can fund the work, direct the work, and approve the work, yet still not own the underlying code unless the contract clearly transfers those rights.
The Work-for-Hire Trap for Contractors and Agencies
Many buyers assume “work for hire” solves everything. It often does not.
In the U.S., work-for-hire is narrower than most non-lawyers expect. It can apply automatically in employer-employee relationships, but for contractors it usually requires very specific conditions and written terms. If you hire a software development company and the agreement uses vague language like “client owns all deliverables,” that may be weaker than an actual assignment clause transferring copyright and related IP.
That is why many diligence issues show up later. The buyer thought they purchased ownership, but the paper trail only purchased usage rights, a license, or an unclear promise.
Background IP Versus Foreground IP
The cleanest software development IP ownership structure separates what existed before the engagement from what was created during it.
- Background IP. The agency’s existing frameworks, libraries, templates, internal tools, and reusable methods.
- Foreground IP. The custom work created specifically for your product.
In our view, a fair deal can let the vendor keep background IP while assigning the foreground IP to you. The danger is when that split is not explicit. Then a founder may unknowingly depend on vendor-owned building blocks that are not fully transferable, or discover that the “custom” app sits on proprietary scaffolding they do not control.
The Three Layers of Real Ownership
This is the framework we recommend founders use before signing any build agreement.
1. Legal Ownership
Before work starts, the contract should answer four questions clearly:
- Who owns the foreground code, design, documentation, and other deliverables?
- What exactly is assigned, not just licensed?
- What background IP remains with the vendor?
- What open-source components are included, and under what licenses?
For a buyer, the right language is usually less important than the right outcome. You want an assignment of all custom-created deliverables, a defined list of excluded pre-existing materials, and a representation that the vendor has the right to grant what it is granting.
If you are reviewing a contract, look for the difference between license and assignment. A license gives permission. An assignment transfers ownership.
2. Operational Ownership
Legal ownership is not enough if only one vendor can run the system.
Use the Two-Week Handover Test. Could a competent new senior team take your repo, documentation, tests, CI/CD setup, cloud accounts, secrets management, and deployment process, then ship a safe change within two weeks?
If the answer is no, you do not truly control the asset. We cover how to judge a codebase without reading it in how to evaluate code quality when you cannot read code.
This is where many build relationships become quiet lock-in:
- No meaningful documentation
- No test coverage or brittle tests
- Infrastructure only the vendor can access
- Architecture known only to one engineer
- Deployment pipelines tied to vendor-managed credentials
- Dependencies on private tools or unpublished scripts
You can own code and still be unable to operate it. That is de facto dependency, which matters just as much during a founder transition, a financing process, or an acquisition review.
3. Provable Ownership
In the AI era, the question is not only if you own the code. It is if you can prove who authored it, how it was produced, and if the chain of authorship supports your diligence story.
That matters because uncoached AI-generated output can create a copyrightability problem. If code is generated with little human shaping or review, the authorship record becomes murky. Investors and acquirers will ask if the code was written by humans, if AI was used as a tool, and if the resulting work can be defended as human-authored enough to support copyright claims.
For founders who prototyped with Replit, ChatGPT, Claude, or similar tools, this is not theoretical. “Does ChatGPT own my code?” is the wrong framing. The real question is if your team can establish that humans made the substantive creative and technical decisions, and that AI was used as an instrument and not the author.
AI does not remove the need for authorship. It raises the standard for showing that a human shaped the work, reviewed it, and accepted responsibility for the code that shipped.
How AI Changes Who Owns the Code
It changes the diligence burden, not the business necessity.
As a buyer, we think you should expect an AI-assisted workflow to have three properties:
- Human direction. Senior engineers define the architecture, boundaries, and acceptance criteria.
- Human review. Every meaningful change is reviewed by a qualified engineer, not merged from raw output.
- Human accountability. Commit history, reviews, and issue tracking show who decided what and why.
This is the difference between coached AI and vibe-coded AI. Coached AI can accelerate delivery while preserving a defensible authorship trail. Vibe-coded systems may be faster at first, but they can leave you with unclear provenance, weak quality control, and a harder story in diligence.
For a founder heading into fundraising or acquisition, that provenance matters. A clean repository history, meaningful pull request reviews, and engineering discipline are not just process artifacts; they are evidence that the product is owned and operated like a real asset. We explain why review carries so much weight in why code reviews matter more in small teams.
The Lock-In Traps That Survive a Signed IP Clause
Some vendors are perfectly willing to sign an ownership clause and still create dependency through execution. We watch for these traps:
- Repo not in your org. If the source code lives in the vendor’s account, control is still external.
- No environment handoff. If production access, cloud credentials, and CI/CD live elsewhere, you cannot operate independently.
- No tests. Without tests, every change becomes risky tribal knowledge.
- No docs. If onboarding a new engineer takes days of vendor explanation, you have operational lock-in.
- Bus factor of one. If one person knows the architecture, you do not own a maintainable system.
- Proprietary foundation hidden under “custom” work. If the core is a private framework, your asset may be less portable than you think.
These are not theoretical annoyances. They are the exact problems that surface during diligence, when a buyer asks how quickly the company can onboard a new team, continue development, and prove that the product is not dependent on one external actor.
What to Ask a Build Partner Before Signing
We use questions that reveal both the contract structure and the operating model:
- Will the repo live in our organization from day one?
- What is assigned to us, and what is merely licensed?
- What background IP, templates, or frameworks will remain yours?
- Which open-source components do you use, and how are they tracked?
- How do you document architecture, deployment, and key decisions?
- What does handover include at the end of the engagement?
- Can you show a past handover where another team took over successfully?
- How do you review AI-assisted changes before merge?
- What evidence will we have of authorship, review, and approval?
If a partner cannot answer those questions cleanly, they are asking you to trust an ownership process you have not seen. For a founder comparing partners for custom software development, that is not enough.
How We Handle Ownership for Clients
We structure engagements so ownership is not an afterthought. The codebase lives in the customer’s repo from day one. The goal is simple. If the engagement ended tomorrow, the customer would keep the asset and keep building.
That is what “the codebase is yours” means in practice. Not a clause in isolation. A structure that supports legal transfer, operational continuity, and provable authorship.
Paying for software is the beginning of the ownership test, not the end. Founders who get the question of who owns the code right do not just buy code. They acquire an asset they can prove, operate, and defend, and that is the work we do at Better Software.
Frequently Asked Questions
Who Owns Software Code If There Is No Contract?
Usually the author does. If there is no written agreement assigning rights, the payer often does not automatically own the code, even if they commissioned it. We always recommend getting an assignment in writing before work starts, so the question never has to be argued later.
Who Owns the Copyright in a Work for Hire?
In a valid work-for-hire arrangement, the employer or commissioning party may be treated as the legal author. But we stress that the doctrine is narrow, especially for contractors, so the label alone is not enough. The contract must actually fit the legal requirements.
Does ChatGPT or Claude Own the Code It Writes?
No. In our view the practical issue is not if the tool “owns” the code, but if the resulting output has a clear human author and a defensible record of human control, review, and acceptance. We look for that record in commit history and reviews.
What Should a Code Handover Include?
At a minimum we expect the source repo, documentation, architecture notes, test suite, build and deployment instructions, environment setup, cloud and tooling access, secrets transfer process, and a walkthrough of any vendor-specific dependencies, so another team can ship a change safely.
What Is the Difference Between Background IP and Foreground IP?
Background IP is what the vendor owned before the engagement, such as frameworks, libraries, and templates. Foreground IP is the custom work created for your product. We think a fair deal lets the vendor keep background IP while assigning foreground IP to you, with the split written down explicitly.
About the author
Better Software Team
Product and engineering team
Better Software Team is the product and engineering team at Better Software. We build new software products and improve existing applications and systems, with deeper experience in healthcare, finance and energy.