Guides

Handing an AI-built app to a client: what to deliver

The short answer: Hand over the code in a repository the client owns, a CLAUDE.md and plan files that explain it, a list of where every secret lives (not the secrets themselves), and short notes on how to run, check and update it.

Key points

  • What lives in your head and in old conversations has to end up in files the client owns.
  • Write down where every secret lives and how to replace it, never the values.
  • Transfer every account and service to the client, and confirm they can sign in.
  • Afterwards, remove your access, delete local copies and replace any key you had.
On this page
  1. What does a client expect when I hand over an app?
  2. 1. The code, in a repository the client owns
  3. 2. A CLAUDE.md that explains the project
  4. 3. The plans and decisions
  5. 4. The checks
  6. 5. A list of where every secret lives
  7. 6. A list of accounts and services
  8. 7. How to run, change and release it
  9. 8. A way for the client to keep building with Claude Code
  10. 9. Known problems and next steps
  11. 10. A walk-through with the client
  12. What should I take back after the handover?
  13. The checklist

What does a client expect when I hand over an app?

They expect to be able to keep going without you. If you built the app with Claude Code, that is possible, but only if what lives in your head and in your old conversations ends up in files. Claude starts each session fresh, so what the client’s next developer or the client’s own Claude session knows is exactly what you leave in the project (Claude Code docs: memory).

Here is what to deliver, in order of how much it matters.

You hand over

  • The repository, with history
  • CLAUDE.md
  • Plans and decisions
  • Tests and one check command
  • Secrets list, no values
  • Accounts list
  • Run and release notes
  • Known problems

Then you remove

  • Your access
  • Local copies
  • Every key you had
What goes to the client, and what you remove once it is done.

1. The code, in a repository the client owns

  • Create the repository under the client’s account, or transfer it to them. Do not leave the only copy in your own account.
  • Include the full history. It shows what changed and why.
  • Check the license of every package you used, so the client knows what they are allowed to do.
  • Remove everything that doesn’t belong to the client: your personal settings, test accounts, old experiments.

2. A CLAUDE.md that explains the project

This is the file Claude Code reads at the start of every session. For a handover it should say, in under 200 lines (the docs’ target size):

  • What the app is, in two sentences.
  • The commands that run it and check it.
  • The decisions that are not obvious from the code.
  • The traps: things that look wrong but are intended.

The best-practices page says the file works best when it holds only what Claude couldn’t work out from the code. Our guide on writing a CLAUDE.md goes into detail. If the client’s team uses other AI coding tools, the memory docs describe how an AGENTS.md can be shared with Claude Code through an @AGENTS.md import.

3. The plans and decisions

Hand over the plan files you wrote for each feature, and a short list of decisions: what you chose, what you rejected and why. Keep one plain note at the top that says what the app is for, who uses it and what must never break.

Without this, the next person re-decides everything, and often un-decides something you had a good reason for.

4. The checks

  • Tests, and a single command that runs them.
  • The result of the last run, so the client sees the starting point.
  • A short manual walk-through of the main path, for the things tests don’t cover.

The best-practices page calls a pass-or-fail check the thing that lets Claude close the loop itself. A client who has one can change the app and know whether they broke it.

5. A list of where every secret lives

This is the part most handovers get wrong. Write down every secret the app needs, and for each one:

  • its name (for example PAYMENT_SECRET_KEY),
  • what it is for,
  • which service issued it,
  • where it is stored now (settings file, hosting dashboard, secrets manager),
  • how to replace it.

Watch out

Do not write the values in the file. Do not send them in a chat or email.

Have the client create their own accounts and keys, and put those in. Then remove your own access and replace anything you had used, so no key of yours still works.

6. A list of accounts and services

The app probably sits on several services: hosting, a database, an email sender, a payment provider, a domain, analytics. For each, list:

  • what it does for the app,
  • who owns the account (it should be the client),
  • what it costs,
  • where to find the invoices,
  • who to contact.

Transfer ownership to the client or add them as owner, and confirm they can sign in. Many handovers fail on one forgotten domain or database that is still under the builder’s name.

7. How to run, change and release it

A short note, in plain language, that answers:

  • How do I run it on my computer?
  • How do I check that it works?
  • How do I put a new version live?
  • How do I go back to the last good version?
  • Where do I look when something is broken?

If you use skills to automate a release or a review, hand those over too. They live in .claude/skills/ in the project, and the docs say committing them shares them with everyone who works on it (Claude Code docs: skills). Check them for anything that has your personal details in it.

8. A way for the client to keep building with Claude Code

If the client wants to continue the way you built it, tell them what they need. The Claude Code quickstart lists it: a Claude subscription (Pro, Max, Ultra, Team or Enterprise), a Claude Console account, or access through a supported cloud provider (quickstart). They need their own, not yours.

Give them a first-session script:

  1. Open the project folder and start claude.
  2. Ask: “What does this project do? Read CLAUDE.md and the plans first.”
  3. Run the check command and see it pass.
  4. Make one tiny change, and run the check again.

If they then ask for a change, they should use plan mode first. Hand over the guide on planning if they are new to it.

9. Known problems and next steps

Be honest. A list of what is not finished, what you know is weak, and what you would do next is a service, not a confession. It saves the client from finding out later.

Include:

  • bugs you know about,
  • things you did not test,
  • shortcuts you took on purpose,
  • security checks done and not done, and what you recommend before launch,
  • the next three things you would build.

10. A walk-through with the client

Do a call or a meeting of an hour. Show the app, show the files, run the checks together, open the secrets list and the accounts list. Have the client run it themselves while you watch. Write down their questions and add the answers to the notes.

What should I take back after the handover?

  • Remove your access to the repository, the services and the accounts, or agree in writing what access stays and for how long.
  • Delete local copies of the client’s code and data that you no longer need.
  • Delete or replace any key you ever had.

The client’s code and data are theirs. Leaving access open by accident is a risk for both of you.

The checklist

  • Repository owned by the client, with full history.
  • CLAUDE.md under 200 lines, current and true.
  • Plans and decisions written down.
  • Tests and one command to run them; last result recorded.
  • Secrets list: names, purpose, where stored, how to replace. No values.
  • Accounts list with owners, costs and contacts; ownership transferred.
  • Run, change, release and roll-back notes.
  • Skills and settings checked for personal details.
  • Known problems and next steps listed.
  • Walk-through done; your access and local copies removed.