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
| What you notice | Common reason | First thing to do |
|---|---|---|
| The agent reports success and the feature still fails when you try it | Nothing checks the work except the agent's own reading of it | Write the journey down as steps and run it by hand after every session |
| A feature that worked before is broken and you cannot say since when | Many changes went in without commits you can tell apart, and nobody read them | Go back through the saved versions to find the last one where it worked |
| The app runs on your laptop and you do not know how to put it online | No deployment was set up, or one was set up in a session you no longer remember | Ask where the app is hosted, under which account, and what triggers a release |
| You are unsure whether a password or key is stored in the repository | Keys were pasted into code, or a local settings file was committed with everything else | Have the repository and its history searched for anything that looks like a key |
| Each new feature takes longer and breaks more | Duplicate and leftover code that the agent has to work around | 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.
- The journeys the business depends on, each as numbered steps with the expected result.
- The last commit where all of those journeys passed.
- A plain-language description of the project, saved in the repository.
- Where each key is stored, without the key itself, and whether any was ever committed.
- Where the live app runs, what releases a new version and how to put the old one back.
- The one task for this session, stated in a sentence.
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 consultationOn 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.