From prompt to production: keep the repo
The second feature changes the question
An AI-built prototype can prove that a screen and an idea belong together. The next feature asks a different question: can you keep changing the app without losing track of how it works? That is where the move from prompt to production becomes a repository and operating decision, not just an export button.
You do not have to leave a builder as soon as the first screen works. If you are still testing the product idea, the fastest place to iterate may still be the tool that created it. When you are ready to add a feature, fix a bug, or bring in another developer, take a small, reversible step: put the source in a repository you control and test whether a coding agent can understand the project there.
The source code is only one part of that handoff. Your app may also rely on environment variables, a database, authentication, file storage, deployment settings, and a model provider. An exported repository does not automatically transfer those services or their credentials. Make a list before you move so you can distinguish source that is present from infrastructure you still need to configure.
Keep the useful parts of the first workflow
Prompt-driven builders are useful when they turn a description into something you can inspect and revise. A repository workflow is useful when you need to examine files directly, compare changes, keep a review history, and run the project’s own checks. These approaches can be used at different points in the same project; choosing a repo does not require you to deny that the first builder helped.
Start by checking what the builder’s current export or Git workflow actually provides. Look for the files that make up the application, its package manifest, and any documented setup steps. Then make a clean copy or branch before editing. If the project depends on a hosted database or sign-in provider, record which parts live in the code and which settings must be configured in that provider’s console. Do not copy secret values into the repository to make an agent’s first run easier.
The point of this check is not to label one tool “real” and another “fake.” It is to learn what work remains for this app. A source tree may be editable while still requiring credentials, service configuration, or a deployment process. Conversely, you may be able to keep using the original builder while storing changes in a repository. Verify the path you will use instead of assuming every product handles export the same way.

12 production screens. Login and database wired.
The SaaS Dashboard Kit includes login, a database, and a working dashboard. Live demo at saas.otf-kit.dev.
Give the repository a short working brief
A coding agent can read files from the repository, but it still needs help finding the right conventions and checks. Put the durable project facts in version-controlled instructions: the framework, important directories, how to run the relevant checks, and decisions a future change should preserve. Keep secrets, temporary debugging notes, and guesses out of that brief.
OpenCode’s documentation describes AGENTS.md as a project instruction file whose contents are included in the model’s context. That makes it a place to explain how the project should be worked on; it is not a database of conversation history, and it does not guarantee that an agent will follow every instruction. Review the file with the same care as other project documentation. See the OpenCode rules documentation for its behavior, and the OTF OpenCode guide for a dated example of one kit test.
On 13 October 2026, the kit's own type-check passes in a fresh install. That is the specific check recorded in the guide. It is not a claim that every app runs, builds, or deploys successfully, and it is not evidence about your project. Run your own check after installing dependencies and record the exact result you observe.
Turn one request into a reviewable change
Before asking an agent to change the app, ask it to inspect the repository without editing. Have it identify the entry points for the feature, the existing pattern it would reuse, the checks available, and any missing configuration. Compare that inventory with the files yourself. If the answer is vague or conflicts with the code, narrow the request before allowing a write.
For the implementation step, name the user-visible result, the boundaries of the change, and how you will verify it. For example: “Add a project settings screen using the existing route and form patterns. Do not change authentication or database schema. Show the files you plan to edit first; after approval, implement the screen, run the existing type-check, and report its exact output.” This prompt keeps the work tied to the app’s current conventions without pretending that the prompt can replace code review.
Keep the change small enough to inspect. Review the diff, confirm the agent did not add a dependency or alter a service configuration without a reason, and run the project’s relevant checks yourself. If a check fails, separate a pre-existing failure from a change introduced by the current branch. If the project has no documented check, record that gap rather than saying the change is verified.

A sandbox helps test a prototype; a repository lets you inspect and continue it.
Separate the app from the services it calls
Moving source into a repository does not move a running database, configure authentication, provision hosting, or transfer a model account. Write down the service each feature calls, the project or account that owns it, how local development is configured, and which values must be supplied outside the repository. Keep real secrets in the appropriate secret store; use example names or placeholders in documentation.
This inventory helps you avoid a false handoff. The code may contain a database client, for example, while the database itself, access policies, and environment variables still need to be set up. Treat each dependency as a separate check: can you identify it, do you control the account, is its configuration documented, and can you test it without exposing credentials?
The same applies to release work. A build command is not a deployment, and a repository does not prove that the live service has the right environment. Use a staging target when available, confirm which project receives the deployment, and verify the live behavior that matters to the user. Decide who owns follow-up changes before the first release, not after an unfamiliar alert arrives.
What an editable starting point should include
When comparing a starter repository with a hosted builder, compare the actual handoff: source access, instructions, setup steps, required accounts, and the checks you will need to run. Ask whether you can inspect the code before buying, which services are already wired, and what remains yours to configure. A starter can reduce setup work without eliminating the work of understanding and operating your app.
The handoff should be testable on a clean checkout. Confirm that the documented install works, that the project’s checks are discoverable, and that the instruction files match the current code. Test one small change on a branch. Those observations tell you more about whether your agent can keep working in the repository than an unsupported promise about how much time any team will save.
OTF’s live pricing page lists full-stack kits at $99 each, one-time, with 12 months of updates; the page says source access is delivered through a license email and repository-access link. Every kit’s current AI configuration includes AGENTS.md, CLAUDE.md, .cursorrules, and 22–27 task prompts, depending on the kit. Check the specific kit and its live demo before choosing. These are starting files and source code, not a guarantee that an agent will make a correct change or that your app’s external services are configured.
A practical prompt-to-production handoff
Use this sequence when you are deciding whether the repository can carry the next stage of work:
- Confirm that you can access the complete source in a repository you control.
- Make a clean copy or branch and note the required services and environment values without adding secrets.
- Read the project instructions and compare them with the actual scripts, routes, and configuration.
- Ask the agent for a read-only map of the feature and its existing implementation pattern.
- Approve one bounded change, inspect the diff, and run the checks the project documents.
- Verify external services and deployment separately from the local code change.
- Record what worked, what failed, and what still needs an owner before calling the handoff complete.
If you want an editable codebase to evaluate, OTF’s SaaS Dashboard kit and Fitness kit are listed at $99 each on the live pricing page, checked on 15 October 2026. Review the demos, license details, and included files first. The kit is optional; the workflow above applies to a repository you already own too.
For a broader guide to keeping project instructions useful across coding sessions, see owning your AI agent’s context. If you want to explore a repo-based starting point, start here and check the current kit details before choosing.
Sources
- OpenCode rules documentation — describes how OpenCode uses
AGENTS.mdproject instructions; checked 15 October 2026. - OTF OpenCode guide — the dated type-check observation and its limits; checked 15 October 2026.
- OTF pricing — current kit price, updates, source delivery, and AI-config prompt range; checked 15 October 2026.
Ship the product, not the setup.
- 12 production screens — auth, team, analytics, and settings
- Login and a real database are wired in
- AI configs pre-tuned so your agent extends instead of regenerates
Ship your first screen tonight — free starter in your inbox
The quickstart, the SDK repo and the live kit demos, on this screen and in your inbox.
No spam. Unsubscribe any time.