Claude Code Prototype to Production: The Missing 20 Percent

By jocapps4 min read

Short answer: Claude Code can produce a convincing prototype in days, but production requires the less visible 20 percent: automated tests, security and access control, error handling, observability, data migrations and backups, performance under load, and a release process with clear ownership. Plan that work explicitly instead of discovering it after launch.

On this page

What separates a Claude Code prototype from a production app?

A prototype proves that an idea works for a friendly user on a good connection with fresh data. Production means it keeps working for impatient users, on bad networks, with years of data, during partial outages and after the person who built it moved on. Claude Code is excellent at the first part. The second part is mostly not about writing more features.

The missing 20 percent rarely shows up in demos, which is why it is underestimated. It consists of tests, security, operational visibility, data safety, performance and release discipline. Each item is individually manageable, and Claude Code can do much of the implementation. What it cannot provide is the judgment about which risks matter for your users and who is accountable when something breaks.

Tests: the foundation for every later change

Prototypes built through rapid prompting usually have few or no tests. That is acceptable for exploration, but the moment real users depend on the app, every change by the agent risks breaking something that worked yesterday.

Start with a thin, high-value layer rather than chasing coverage numbers. End-to-end tests for login, the core workflow and payment protect the most important paths. Unit tests for calculations, permissions and data transformations protect the logic that is hardest to verify by clicking. Claude Code writes these tests well when you describe expected behavior precisely, and once they exist, it can verify its own changes against them.

Security, errors and observability

These three areas turn an app that works into an app you can operate.

  • Authorization enforced on the server for every endpoint, not only hidden buttons in the interface.
  • Secrets in a secrets manager or platform settings, rotated when people leave.
  • Input validation and rate limiting on public endpoints, especially login and AI features.
  • Consistent error handling that shows users a helpful message and logs details for the team.
  • Error tracking, structured logs and uptime checks with alerts that reach a person.
  • Dependency updates on a schedule, with security advisories monitored.

Need a hand? apprat.io helps with exactly this. Book a call for free and get a clear plan in 15 to 30 minutes.

Data, performance and scale

Data outlives code. A prototype's database schema was often generated on the fly and changed by prompts without migrations. Before launch, introduce versioned migrations, define backups with a tested restore, and decide on retention and deletion rules that match your privacy policy.

Performance problems usually come from a few patterns: queries inside loops, missing indexes, loading entire tables into the client and unbounded lists. Seed a staging database with realistic volumes, for example a year of expected data, and measure the slowest screens. Claude Code can then fix the specific bottlenecks you found rather than optimizing blindly.

A production readiness sequence

Work through the missing 20 percent in an order that reduces risk early.

  1. Freeze new features for a short hardening sprint and agree on launch criteria.
  2. Add end-to-end tests for the critical paths and run them in CI on every change.
  3. Review authorization, secrets and input handling; fix all critical findings.
  4. Set up staging, error tracking, logging, uptime monitoring and alerting.
  5. Introduce database migrations, backups and a restore drill.
  6. Load-test the slowest screens with realistic data and fix bottlenecks.
  7. Define the release process: review, approval, rollback and who is on call.

Ownership: the part no agent can take over

Even a perfectly hardened codebase needs people who own it. Someone must review what the agent changes, decide trade-offs, respond to incidents and talk to app store reviewers. Without that, quality erodes release by release.

Teams handle this in two ways. Some build the skills internally: neooutput offers workshops, trainings and 1:1 consulting on agentic coding with Claude Code, including testing strategies, review workflows and release practices, so the team can run the missing 20 percent itself. Others prefer to hand over the responsibility.

apprat.io is built for the second path. Its Prototype-to-Production module takes an existing Claude Code project, adds tests, security fixes, monitoring and a release pipeline, and then continues development with coding agents under the review of named senior AI Code Engineers who also test on real devices and publish to the App Store and Google Play. apprat.io plans start at 129 EUR per month including AI Code Engineer hours, with a 30-day free trial.

Both paths work, and many teams combine them: apprat.io for delivery now, neooutput training so the internal team can take over later. A free call helps decide which mix fits your situation.

Frequently asked questions

Can Claude Code make my prototype production-ready by itself?

Claude Code can implement most of the hardening work, including tests, validation, logging and migrations, if you specify it clearly. What it cannot do is decide which risks are acceptable, verify behavior on real devices and networks, or take responsibility for incidents. That still requires experienced people.

Should I rewrite the prototype before going to production?

Usually not. Most prototypes can be hardened incrementally: tests first, then security, observability and data. A rewrite is justified when the architecture fundamentally cannot support your requirements, for example the wrong data model or platform. Assess this early with a short code review.

How long does the hardening phase take?

For a focused app, a hardening sprint of two to four weeks is a common range, depending on the state of the code, integrations and compliance needs. Larger or regulated products take longer. Defining launch criteria upfront keeps the phase bounded.

What is the most commonly skipped production step?

Restore testing. Many teams configure backups but never restore one, and discover problems only during an incident. Run a restore drill before launch and repeat it periodically, so you know how long recovery takes and that the backups are complete.

Also useful for this

Talk to an AI Code Engineer, free of charge

Tell us where you are and where you want to go. In a short call we map out the fastest path, whether that is a workshop, a launch in the App Store and Google Play or a full AI-native product.

No obligation. English or German. Run by jocapps, ISO 27001 and ISO 9001 certified. Prefer the phone? 24/7 call support: +49 761 519 751 50

Book a call for free

Related guides

Book a call for free