When a contractor claims ownership of the code: what to do first
A contractor's claim to code ownership rarely settles by argument. The first task is procedural: freeze the repository, locate the assignment clause, and calendar any deadline the claim already started. Ownership itself follows the contract and the applicable copyright regime — not who wrote the last commit or who shouts louder first. Acting within the first days protects the client's evidentiary position more than any statement of principle ever will.
Legal basis
Computer programs are protected as literary works under Directive 2009/24/EC. The directive sets the EU-wide floor for software copyright. It does not itself decide who owns the code as between a client and a contractor — that allocation is a matter for the development agreement and for the copyright rules of the jurisdiction the contract is governed by.
Where the agreement is silent, most national regimes place initial authorship — and with it, initial ownership — on the individual who wrote the code, not on the company that paid for it. A written assignment is therefore the fact that matters, not the coding work itself. Where the disputed deliverable also includes a compiled dataset, the adjacent protection regime is Directive 96/9/EC, which covers databases separately from the software that runs on top of them.
Practical consequence
Without a clean assignment on file, the client typically holds a licence implied by the course of dealing, not ownership. An implied licence is narrower than ownership. It rarely covers modification, sublicensing, or resale of the code as a standalone product.
If the contractor later disputes scope, what is actually at risk is the client's freedom to maintain, extend, or sell the software — not an abstract label of "ownership". That is the practical stake behind every step that follows.
What to do first
- Pull the development agreement and locate the IP clause, word for word. Executor: the contract manager on the client side.
- Preserve the repository state — commit history, timestamps, branch structure — before anyone touches the code again. Executor: the engineering lead.
- Separate what was delivered under this contract from prior work, open-source components, and code reused from other engagements. Executor: the technical lead.
- Calendar the response deadline stated in the contractor's notice, if one was served, and any period set by the contract's dispute-resolution clause. Executor: legal counsel.
- Draft a written response that neither concedes scope nor escalates tone before the facts are confirmed. Executor: counsel, reviewed by the contract manager.
- Escalate to the forum named in the contract only once internal fact-finding is closed. Executor: counsel.
Who decides
The forum is whatever the contract names — a court or an arbitral tribunal — and it decides on documents, not on who is more persuasive at the first meeting.
| Scenario | Who decides | On what evidence |
|---|---|---|
| Contract has an explicit assignment clause | Usually resolved on the wording alone, no forum needed | The clause text and the delivery schedule it refers to |
| Contract is silent on ownership | Court or arbitral tribunal named in the agreement | Commit history, invoices, correspondence, course of dealing |
| Contractor used third-party or prior code | Same forum, narrower claim | Origin of the disputed component, its own licence terms |
Forks
If the contractor's claim overlaps with a separate dispute over contract terms — for instance, a customer on the same engagement is separately pushing for uncapped liability — treat the two disputes on separate tracks in correspondence, even where the same counterparty raises both. See A customer demands unlimited liability technology contract for that track on its own.
If the disputed code was built for a tokenised product and the ownership question resurfaces once the offering document itself is challenged, resolve the code file first. The ownership question is usually the simpler one to close, and closing it first narrows what the offering-document dispute is even about. See When the offering document is questioned in detail.
Sources and limits
This page does not establish who owns a specific codebase. It maps the first procedural moves once a claim is made, nothing further. If the dispute escalates to enforcement and assets need tracing across a Lithuanian entity, that is a separate file with its own sources — see Asset in Lithuania in practice.
If the contractor's business itself becomes insolvent while the ownership claim is still open, the claim changes character and different deadlines start running — see Debtor in Lithuania and the deadline.
Verified: 2025-05-01. Sources: Directive 2009/24/EC (EUR-Lex); Directive 96/9/EC (EUR-Lex), consulted where the disputed deliverable includes a dataset alongside the code.
Related situations
A closely related first-days problem sits on the design side rather than the code side: see When an agency keeps the design files in practice, where the same freeze-first logic applies to design deliverables instead of a repository.
FAQ
What is the first step when a contractor claims ownership of the code?
Freeze the repository state and locate the assignment or licence clause in the development agreement. Ownership follows that clause and the applicable copyright default rule, not who last touched the code.
Which deadline is already running?
Any deadline stated in the contractor's written notice, if one was served, plus the response period set by the contract's dispute-resolution clause. Missing it narrows the client's options before the substantive question is even reached.
Who decides, and on what evidence?
The forum named in the contract — a court or an arbitral tribunal — decides on the wording of the assignment clause, the commit history, and the course of dealing between the parties.