# Every engineering engagement ends. Plan the exit before you sign.

The cheapest moment to arrange a clean handover is before the first commit. What you must own, what AI-native delivery adds to the list, and how to rehearse leaving while everyone is still friendly.

By Precision Code Studios. Published October 5, 2026. Category: Delivery. https://www.precisioncodestudios.com/insights/plan-the-exit-before-you-sign

The engagement has gone well, the product is live, and then something changes. Funding shifts, priorities move, you build an in-house team, or you simply want a second opinion. You ask for the keys and find out what you actually own. The cloud account is billed to the vendor. The domain was registered by an engineer who left last spring. Releases run from a script nobody wrote down. None of it was malicious. It is simply what happens when nobody plans the ending.

Every engagement with an outside engineering team ends, whether in six months or six years. The cheapest moment to arrange a clean exit is before the first commit, when every request is easy and nobody's feelings are involved. What follows is the checklist we would want a client to use with any partner, including us.

## Why a managed team needs an exit plan most

When you embed engineers in your own team, most of the knowledge stays with you: they work in your repositories, your tickets and your chat. A managed team is different by design. You are buying accountability for delivery, so the team makes most of the decisions, holds most of the context and runs most of the machinery. That is exactly what you pay for, and it is also why the handover has to be designed rather than hoped for.

None of this is about distrusting your partner. It is about making sure that what you pay for accumulates on your side of the table, sprint by sprint, instead of in someone else's accounts and memory.

## Own four things, not just the code

"You own the IP" appears in almost every contract, and on its own it protects you less than it sounds. Code in a zip file is not a working product. Ownership that survives a handover has four layers, and each one comes with a test you can run.

*Figure: A table of four ownership layers: accounts, build and deploy, knowledge, and rights. Each row lists what the layer covers and a practical test that shows whether you really own it. Each layer has a test. If you cannot pass it, you are renting that part of your product.*

- **Accounts.** The repository, cloud subscription, domain and DNS, app store developer accounts, payment provider, email service and monitoring are registered to your company, paid by your company, with your people as administrators. The vendor's engineers are invited as members. The test: could you remove the vendor's access tomorrow without anything going dark?
- **Build and deploy.** The pipeline that tests and releases the software lives in your repository and runs on infrastructure you control. Passwords and keys sit in a secrets vault you administer. The test: can an engineer who has never seen the project build and deploy it from a clean checkout, using only what is written down?
- **Knowledge.** Architecture decision records, which are short notes saying what was decided, what the alternatives were and why, plus runbooks for the jobs that happen at three in the morning. The test: when a new engineer asks why something is built the way it is, is the answer in the repository or in a person?
- **Rights.** A clear assignment of intellectual property, an inventory of the open-source components the product uses and their licences, and a plain statement of any vendor-owned libraries inside it. The test: could you get through an investor's or acquirer's due diligence on the codebase without phoning the vendor?

> **The one test:** If you could not remove your vendor's access tomorrow without something going dark, you do not own your product yet. You are renting it.

## What AI-native delivery adds to the list

Teams that build with AI coding agents produce more than code. They write instruction files that tell the agents how the project is organised, prompt libraries for recurring tasks, scripts that wire the agents into testing and review, and sometimes evaluation sets that check the agents' output. A good share of a modern team's speed lives in that machinery. If it stays in the vendor's private tooling, you receive the code without the thing that made it fast, and your next team starts slower than the last one finished.

The fix costs nothing if you ask early. Agent instructions and prompts that are specific to your product belong in your repository, versioned like any other file. The same applies to anything your product itself does with AI. If your application calls a language model, then its prompts, its evaluation data and the API account are part of the product, not part of the vendor's toolkit.

There is also a legal wrinkle worth a conversation with your lawyer. In the United States, the Copyright Office's January 2025 report on copyrightability reaffirmed that work created solely by AI, without human involvement, is not eligible for copyright protection. In March 2026 the Supreme Court declined to hear Thaler v. Perlmutter, leaving in place the appeals court ruling that a copyrighted work needs a human author. Code that engineers design, direct, edit and review is a different case from code an agent produced unsupervised, but the boundary is not settled, and an IP assignment clause can only transfer rights that exist. The practical response is to keep the evidence of human authorship that good teams produce anyway: design documents, decision records, reviewed pull requests and a meaningful commit history. Rules differ between countries, so treat this as a question to raise, not an answer.

## Rehearse leaving while everyone is still friendly

Documentation that nobody has used is a hypothesis. The only way to know a handover would work is to try one, ideally halfway through the engagement rather than at the end of it.

The drill is simple. Give someone outside the delivery team, one of your own engineers or an independent reviewer, a fresh laptop, read access to the repository and the documentation, and nothing else. Ask them to build the product, run the tests and deploy to a staging environment without asking the vendor for help. Every question they have to ask is a gap in the handover. Write each one down, get it fixed, and repeat the drill a few months later. It costs a day or two, and it turns "we have documentation" into something you have watched work.

Do the same for access. Every quarter, list everyone with administrative rights to your systems and confirm each one is still needed. Engagements change shape, people rotate, and forgotten access is one of the ordinary mistakes that penetration tests keep finding.

*Figure: A timeline of five stages: accounts in your name on day one, decisions written down every sprint, a clean-room drill mid-engagement, a transition period at notice, and access removed at exit. Handover is a habit that runs through the engagement, not a task saved for the last week.*

## What to write into the contract

- **Named handover deliverables.** Repository, pipeline, infrastructure definitions, documentation, decision records, runbooks, agent and prompt files, and an inventory of credentials. Anything not on the list becomes a favour.
- **A transition period.** An agreed number of weeks after notice in which the outgoing team works alongside your new one at the existing rate: first leading while your people shadow, then shadowing while your people lead.
- **No fee for your own property.** Handing over code, data and access you have already paid for should not be a billable event.
- **Notice that fits reality.** Long enough for a proper transition, short enough that you are not stuck in a relationship that has stopped working.
- **Disclosure of anything the vendor keeps.** If the product depends on a library or framework the vendor owns, the contract should say so and grant you a licence that outlives the engagement.

One thing you may not need is source code escrow, where a third party holds a copy of the code in case the vendor disappears. Escrow makes sense for software that lives on the vendor's side. If your code has been in your own repository since the first commit, escrow protects you from a risk you have already removed.

## Scale the effort to the lifespan

Not every project needs all of this. A six-week prototype you plan to throw away needs the accounts in your name and very little else. A platform you expect to run for five years needs every layer, at least one drill and a contract that spells out the transition. The useful question is how long you will live with the software, not how long the engagement lasts. Those two numbers are rarely the same, and handover costs hide in the gap between them.

It is also worth watching how a prospective partner reacts when you raise the subject. A team that is confident in its work treats an exit plan as ordinary hygiene, because it is. Reluctance to put accounts in your name, releases only the vendor can run, or documentation promised for the end of the project are all worth noticing before you sign rather than after.

> **Remember this:** Ask how long you will live with the software, not how long the engagement lasts. The handover should be sized for the first number.

Underneath all of this is a simple piece of commercial logic. A partner you could leave next month has to earn next month. A partner you cannot leave only has to stop you trying. Make leaving easy, and every renewal becomes a decision you actually made.
