Finish a Claude Code app that will not launch.

You built the app with Claude Code or a similar coding agent working in your own repository. The code is real and it belongs to you, and the app is still unfinished, untested or offline. This page covers the gaps we see most often in these projects, checks you can run without reading the code, and when to bring in an engineer.

What a stuck Claude Code project usually looks like

With a coding agent, the files live in a repository on your machine and in your own account, so you start with more than many founders have at this stage. The trouble tends to show up later. The app runs when you start it on your laptop and you are unsure how to put it on the internet. A feature that worked last week has stopped and you cannot tell which session changed it. The agent says the work is done, and your only way to confirm that is to click around.

In the projects we see, four gaps account for most of this. Nobody has read the code as a whole. Nothing tests it automatically. Private keys sit in places they should not. The route from the repository to a live site is missing, or only the agent that set it up understands it. Each gap has a check you can do yourself. Find your symptom in the table and go to the section that covers it.

Match what you notice to the first thing to do

What you notice
The agent reports success and the feature still fails when you try it
Common reason
Nothing checks the work except the agent's own reading of it
First thing to do
Write the journey down as steps and run it by hand after every session
What you notice
A feature that worked before is broken and you cannot say since when
Common reason
Many changes went in without commits you can tell apart, and nobody read them
First thing to do
Go back through the saved versions to find the last one where it worked
What you notice
The app runs on your laptop and you do not know how to put it online
Common reason
No deployment was set up, or one was set up in a session you no longer remember
First thing to do
Ask where the app is hosted, under which account, and what triggers a release
What you notice
You are unsure whether a password or key is stored in the repository
Common reason
Keys were pasted into code, or a local settings file was committed with everything else
First thing to do
Have the repository and its history searched for anything that looks like a key
What you notice
Each new feature takes longer and breaks more
Common reason
Duplicate and leftover code that the agent has to work around
First thing to do
Ask for a list of files nothing else uses and of features built twice

A codebase that grew faster than anyone read it

A coding agent can write in an afternoon what a person would need a week to read. When you accept each change because the app still starts, the repository fills with code that no person has looked at. Some of it is good. Some of it is a second version of a feature that already existed, a helper nothing calls, or a workaround for a problem that was later solved another way. The agent has to read through all of it on every task, and its changes get less reliable as the pile grows.

You can get a view of this without learning to program. Ask the agent to describe the project in plain language: what each top-level folder is for, which outside services the app talks to, and which parts it would not trust. Ask it for anything that appears to be unused or duplicated. Save the answers in a document inside the repository. Then slow the pace down: one task per session, a commit with a message you understand at the end of each, and a read of the summary of what changed before you accept it.

If you plan to keep building on the app for years, have a person read it once. A review by an engineer tells you which parts are sound and which will cost you later, and that judgment is hard to get from the same tool that wrote the code.

Nothing checks the app except you

A test is a small program that uses one part of your app and reports whether the result was right. With tests in place, a change that breaks sign-up fails a check straight away. Without them, the only signal is you noticing, days later, on a screen you happened to open. Agent-built projects commonly have few tests or none, because nobody asked for them and the app appeared to work.

Start with a list. Write down the handful of journeys the business cannot do without, such as signing up, creating the main record, paying, and getting back in the next day. Write each as numbered steps with the result you expect. Run them by hand after every session until something better exists. Then ask the agent to write automated tests for those same journeys and to run them before it tells you a task is finished.

Read what the tests check before you rely on them. An agent asked to make a failing test pass will sometimes change the test. Ask it to explain each test in a sentence, and treat any edit to an existing test as a change that needs your approval.

One regression traced through the saved versions

Keys and passwords in the wrong place

Your app holds keys to other services: the database, the payment account, email, perhaps an AI model. Each key should live in the settings of the place where the app runs and stay out of the code. In agent-built projects a key often ends up pasted into a source file to get something working, or a local settings file gets committed along with everything else. A key that was ever committed stays in the repository's history after you delete the line.

Ask the agent to search the code and the full commit history for anything that looks like a key or a password, and to list the files where it found them. Check whether the repository is public. Ask which keys are sent to the browser, because a visitor can read anything the browser receives. If a private key turns up in any of those places, replace it with a new one at the service that issued it and switch the old one off. Deleting the line leaves the old key working for anyone who already copied it.

The same care applies when you ask for help. Say where a key is stored and what it is for, and leave the value out. Never paste a password, a secret key or live payment credentials into a contact form, a chat window or an email, ours included. A person who needs access can be invited through the service's own sharing settings.

A deployment you can explain

Deployment is the route your code takes from the repository to the address customers visit. In the projects we see, it is either absent, because the app has only ever run on one laptop, or it was set up by the agent in a session the founder does not remember. Both leave you unable to release a fix with confidence, and unable to go back when a release goes wrong.

You should be able to answer five questions in writing. Where does the live app run, and whose account pays for it? What causes a new version to go out? Where are the live settings and keys kept? Is there a second copy of the app for trying changes before customers see them? How do you put the previous version back? Ask the agent to answer each one from the repository and to write the answers into a file there. Then test the last answer on purpose, on a quiet day, before you need it.

If the app has never been online, deploy it early, before it is finished. An unfinished app at a private address shows you the settings, sign-in addresses and database differences that a laptop hides, while they are still cheap to fix.

When to carry on yourself and when to bring in an engineer

Carry on yourself while the checks above give you clear answers. If the agent can describe the project, the core journeys pass by hand, no private key is exposed and you can release and roll back, then what remains is ordinary building. Keep the sessions small and keep the list of journeys current.

Bring in an engineer when a key that guards customer data or money has been exposed, when the same fault returns after several repairs, when you cannot get the app deployed at all, or when you are about to take payments or store private records and nobody has reviewed the code. The Diagnostic is our fixed-price written plan for that situation. We read the repository, run the app, and write down what works, what blocks launch and what to do first, and the fee is credited to the build if you go ahead with us. We work in your repository under access you grant, so your repo and accounts stay yours.

Before your next session with the agent

Write these down first. They make each session smaller and give anyone who helps you a place to start.

  1. The journeys the business depends on, each as numbered steps with the expected result.
  2. The last commit where all of those journeys passed.
  3. A plain-language description of the project, saved in the repository.
  4. Where each key is stored, without the key itself, and whether any was ever committed.
  5. Where the live app runs, what releases a new version and how to put the old one back.
  6. The one task for this session, stated in a sentence.
How we can help

We can get your Claude Code project launched.

Book a free consultation and tell us what the app does and where it stalls. We will say whether a code read, the Diagnostic or a smaller piece of work fits. If we take it on, we work in your repository, add tests for the journeys that matter, set up a deployment you can run yourself, and hand it all back to you.

Book a free consultation

On the project call, we’ll discuss the problem, your existing tools and what TDAT should take off your hands. Then we can define the scope and next steps.

Or call (919) 289-1231

Questions before we start

Can you finish an app that was built with Claude Code?

Usually. These projects arrive as a normal repository, which an engineer can read, run and test like any other. We look at the code and the core journeys before saying what to keep. Where a part would cost less to rewrite than to repair, we say so and explain why.

Is code written by an AI coding agent good enough to launch?

It varies, often within a single project. In the apps we see, the visible features are frequently sound and the gaps are in testing, key handling, access rules and deployment. Quality follows what was asked for and what was checked, so the answer comes from reading the code and running it.

Do I have to stop using Claude Code if I hire you?

No. Founders can keep building with an agent once tests, a deployment and a review step are in place, because those give the agent's work something to be checked against. Which changes go through review is your decision.

How do I know whether my project has any tests?

Ask the agent to list the automated tests, say what each one checks, and run them. If the list is empty, or the tests only confirm that pages load, treat the app as untested and use the hand-run journey list from this page until that changes.

What do you need from me to review the repository?

Read access to the repository, the address of the live app if there is one, and the journeys that matter, including the one that fails. Send invitations through each service and keep passwords and keys out of messages.