AI coding tools can turn a product idea into a working application quickly. Before giving that application real customer data, check the authentication, database permissions, secrets, and deployment settings. A functional demo does not show whether another user can bypass those controls.
The checks below focus on common failure paths in AI-built applications and a synthetic invoicing example.
What the research examined
A June 2026 study collected more than 9,000 open-source applications built with Claude Code and Lovable and audited 200 deployed applications. It reported at least one vulnerability in 91 percent of the audited sample, with nearly two-thirds of findings rated Critical or High. Broken access control, injection, and authentication failures were prominent. These are results for that sample, rather than a measurement of every AI-built application.
The study described memory, objective, and knowledge defects. An agent may lose an earlier security constraint, prioritize a working feature over an unstated protection, or reproduce an unsafe pattern from its training. Better prompting and harnesses reduced failures without eliminating them. Include explicit security requirements during the build and verify the deployed behavior afterward.
These tools produce applications at substantial scale. Lovable reports more than eight million users and over 100,000 applications created daily, with more than 10 percent deployed publicly. An earlier disclosure identified personal-information exposure in roughly one in ten Lovable-created applications. The relevant question for your release is which controls were verified in the application you built.
Why this differs from a normal software security problem
In an existing codebase, the team can review generated changes before merging them. Security-aware prompts can improve the output, but keep that review step and its tests explicit. Ask the agent to implement the required controls and check the result.
Fast generation can leave less time for review, whether you use an editor agent or a platform that builds the whole application. Test authentication, database rules, secrets, and deployment settings regardless of which tool produced the code.
What to audit before deploying
Authentication: find test credentials, bypasses, and placeholder checks left from prototyping. Verify password-reset validation, session expiration, and logout behavior. Request protected routes directly to confirm that the server enforces authentication even when the interface hides the function.
Database permissions: verify the actual deployed rules for each user and tenant. Check whether row-level security or its equivalent is enabled, and try requesting another test user’s records. Keep service-role and administrator keys out of client code. Do not infer the database’s protection from what the interface displays.
Secrets: inspect source, built browser bundles, configuration, and repositories within scope for API keys and service credentials. Store secrets only where the intended server process can use them. If a live credential was exposed, revoke it at the issuer and update its legitimate consumers.
Deployment: review CORS against the origins the application needs. Disable unnecessary debug output and inspect error responses. Confirm the intended separation of staging and production databases, credentials, and services.
Testing: check misuse cases as well as successful workflows. Use separate accounts to attempt unauthorized reads and writes, unexpected request fields, and repeated actions. If the coding agent reads repositories, issues, or linked documents, review its own access limits for indirect prompt injection too. The application review and the agent-environment review cover different risks.
A representative test: what an audit finds
Consider this synthetic invoicing application. The example illustrates test cases; it does not describe findings from a named customer or platform.
The application: a simple subscription-based invoicing tool, built over a weekend on a popular AI app-building platform, with user accounts, saved client records, and Stripe-based billing. Functionally, it works exactly as intended.
Possible findings include an invoice endpoint that returns another test customer’s billing details after its ID changes, a Stripe secret key in the browser bundle, or an inactive row-level security rule on the clients table. The review may also identify reset tokens that never expire and error responses exposing internal paths. Verify the effect of each issue before assigning severity.
For each finding, retain the request, account used, response, and affected state. That evidence lets the developer reproduce the issue and check the fix.
Why this specifically matters if you don't have a security team
If the team has no security specialist, assign an independent review before launch. Agree what access the reviewer needs and which application functions matter most. The tool that built the product cannot supply independent evidence about its own output.
Scope the review around account permissions, database rules, exposed secrets, production configuration, and misuse cases. Ceron’s core audit is listed at $1,500 on a no-findings, no-fee basis within the agreed terms. Confirm whether the engagement includes the authenticated roles needed for your application.
Add deeper authenticated testing when payment flows, tenant separation, or enterprise requirements call for it. Repeat the affected cases when new features or roles change those controls. Keep the tested version with the report.
Before you deploy: the practical checklist
Before deployment, test protected routes directly and remove prototype credentials or bypasses. Verify database permissions with separate accounts, inspect the built bundle for secrets, and check production errors and CORS. Resolve the findings and retest before real customer records enter the system.
Fast builds still need time for review. Put the permission and deployment checks into the release process so the next generated feature receives the same scrutiny.