Vibe-Coded App Security Audit: What Built-In Scans Miss
Last updated 18 September 2026 · verified against each platform’s own documentation
Releasing your app to the public without a proper audit opens you up to unnecessary risk. Each of the major AI-coding platforms have made strides in the last year to make your app safe before releasing. Replit shipped a Security Agent in April 2026. Lovable scans your app when you publish. Bolt runs a security agent before you deploy, and Base44 runs an automatic scan while advising in their documentation to run a deep scan before you share your app. The included scans, however, will not and cannot assure that your app is ready for the public. Lovable says so plainly: the scan that runs on every publish “doesn’t analyze your application code for logic flaws or vulnerabilities unique to how your app is built.” No scanner is told what your app is supposed to do and will not be able to fully assess your app’s production readiness.Our audit will look at access rules read table by table, tenant isolation tested with real accounts, and business logic that no linter has a rule for. Available for the fixed price of $499.
What is a vibe-coded app security audit?
Understanding the security of your app is essential; if you don’t bother, someone else will. Entire industries are built around probing and exploiting vulnerabilities across the internet. There are tons and tons of tools available to help developers, including vibe coding developers, figure this out, and they often fit into one of several types:
- A scan is the simplest: an automated pattern-matching tool that runs in seconds. Examples include Lovable and Bolt’s built-in scanners, as well as free tools like OWASP ZAP or TruffleHog. These may scan a running instance of your website, your source code itself, or some compiled artifacts. The point is that they are deterministic code that runs against your app in some way, and tells you if vulnerabilities exist matching their criteria in a way they can determine via a strict set of rules.
- An audit, like Aspen Automation’s AI app security audit, is a process wherein a professional engineer uses a number of techniques, including scanning tools, manual reading of source code, and direct interaction with the running application, to build a more holistic view of the state of the application’s security. This deeper analysis often discovers vulnerabilities and areas of improvement that an AI might miss simply because the agent doesn't have the full context of the application, how it fulfills the promise of the product, or how that product fits its role in the business.
- Penetration tests are when security experts attack a running system, with the goal of finding live and exploitable issues with an application, using the same tools and techniques that bad actors would use to actually execute an attack. From a strictly security standpoint, this is the most robust (and priciest) form of scrutiny.
What your platform’s own security scan actually covers
Each of the major AI-coding platforms has made efforts to check generated code for major errors. However, they each approach a security scan and audit differently. Each platform varies on when a scan is run, what is checked for in each scan, and which scans are included with different subscription tiers.
Lovable
Automatic check covers
The Basic scan runs on its own when you open the publish dialog. It checks RLS policy linting, reviews database schema, and verifies dependency versions.
Deeper review coverage
The Deep scan runs a full agentic review that you manually start. It adds reviews of access-control, backend endpoint protection, and code-level vulnerabilities (SQL injection, secrets, XSS, insecure storage, information leakage).
What platform docs say is not covered
"These tools help identify common security issues, but they cannot guarantee complete security."
Docs ↗Scan availability
Basic: Free, included with every plan.
Deep: Free, included with every plan.
Bolt
Automatic check covers
No automatic checks. The whole project or database is scanned only after the user initiates a scan.
Deeper review coverage
One project-wide audit, run from the Publish menu. The audit covers: access control, authentication, business logic, database policies, information disclosures, secrets, injection & XSS.
Scan availability
The full audit is paid-plan only while the database check is free on all plans.
Replit
Automatic check covers
A dependency scan, which checks packages against public CVE records, runs continuously on every plan. A lightweight pattern check also runs automatically on whatever the Agent writes. This catches secrets and insecure patterns as you build but isn't a review of your existing codebase.
Deeper review coverage
A full Security Agent scan must be started manually. It maps your architecture, builds a threat model, analyzes routes and APIs, and verifies whether each finding is exploitable in production.
Scan availability
Automatic Dependency Scan is free on all plans. Security Agent is available on paid plans only.
Base44
Automatic check covers
Nothing. The scan only runs when someone starts it from the app's Security tab.
Deeper review coverage
A scan run before publishing checks: dependencies, exposed secrets, and unauthenticated backend functions. The Builder Plan and above also include a scan of code vulnerabilities. Docs ↗
Scan availability
Manual scan is free on every plan. Code Checks are available only on the Builder plan and above.
What the built-in scans don’t look for
The platform’s own scans are getting better all the time; what started as a couple basic checks has turned into a pretty robust system. Lovable’s deep scan is “a full AI-powered review of your codebase that takes about 2-4 minutes”. Replit’s Security Agent maps your architecture and builds a threat model. Bolt’s agent writes the fixes itself. You can get a lot of value out of these, and if you haven’t run your platform’s version yet, you should make it a priority. However, there are a couple ways in which these scans can fall short:
A rule that looks right and isn’t - The scans can assert that the rules exist, and roughly follow best practice, but they can’t assert that it’s the right rule for your application. Say you create a rule saying that every piece of data belongs to the person who created it. That makes sense, it strictly limits who can see what, and a scan can tell you that you wrote it correctly. But as soon as you have different types of users you can run into issues. Say a front-desk admin at a counseling facility accepts an appointment request and creates a patient record. Then the therapist who sees the patient goes looking for the record. They won’t be able to find it, because it’s only scoped to the admin. So you get the support ticket and say, “Ok, data belongs to the person who wrote it AND users of type ‘therapist’”. The next time a new patient walks into the room, the provider can see the record. Great! But now the provider updates the patient’s profile with session notes. The admin still owns the record, and now all patient notes are going straight to the admin’s desktop. Again, the first version of the rule is solid for some use cases, and the second version is solid for other use cases. But neither is right for your use case, and the platform won’t know that.
Missing everything outside the platform - By definition, the platform’s scans stop at the platform’s boundaries. But every vendor, every third-party api, payment gateway, AI integration, whatever, is a security, privacy, and compliance surface. The scan can tell you that your application is following the rules, as the scan understands them, but it cannot tell you that the payment gateway you’re using is improperly configured, or that your retry policy for a third-party API with strict usage limits is going to jack up your bills.
Biasing towards solutions within the platform - This one’s obvious: the platforms mass produce software. To do so, they build it within certain parameters, namely distinct infrastructure and architecture, that allow them to reach a certain bar of quality for a certain set of software for a large number of people. If those parameters don’t match what’s best for your particular use case, they aren’t going to tell you that; they’re going to tell you the band-aid they can slap on to keep it limping along for a little bit longer.
Not standing behind their results - Lovable phrases it like this: “These tools support secure application development, but they do not replace a thorough security review.” They are designed to catch big holes, but not to holistically understand the shape of the app, nor to help you understand the app. If you have a customer asking for reassurance that their data is safe with you, you want to be able to confidently assert it is, not just say “well today’s scan didn’t show any huge gaps”.
Do you actually need an audit?
Let’s be honest, not every app needs a thorough audit. AI coding has given us all the freedom to create bespoke personal apps. There are many cases where the included platform scans are sufficient, and it will largely depend on the nature of the application. You probably don’t need to perform an audit if your app:
- Is a prototype
- Is an internal tool used by only a handful of colleagues
- Has no outside customer data
- Handles no payments.
The free scan on each platform will handle common failure classes well at that scale.
In the reverse, if your app handles payments in any way, houses HIPPA or other sensitive user data, or is to be used company-wide, then a full audit of the application will be worth having performed.
Some classes of application which will house sensitive user data will require purchasers to fill out a security questionnaire before they can purchase. In this case, you’ll also want a full audit on hand to help smooth sales cycles.
Generally, if your application has more than 10 users, has users outside of your company that depend on working functionality, has more than 5 integrations or more than 10 installed packages, then go with an outside audit.
What an audit covers
- Can the right people access the right parts of the app—and nobody else?
- Is customer information kept private and separated correctly?
- Are passwords, payment keys, and other sensitive information protected?
- Could someone reach data or features they shouldn’t be able to?
- What could break, expose customer information, or become costly as you grow?
You get a severity-ordered report, covering vulnerabilities as well as best-practices to help you speed up delivery, with a remediation roadmap to help you address any issues. Plus a breakdown of your architecture to help you understand your application.
$499 fixed price · 1 week
Book an AuditWhat goes wrong on each platform
The beauty of software development is that there are a million ways to solve any problem. The flip side is that there are a million ways to create a problem out of thin air. Although vibe coding tools and platforms are getting better all the time, there are architectural truths about each system that lend themselves to particular sets of problems.
- Lovable’s standard architecture is one where all authorization (determining who can see or do what) happens on the database, in a series of code-defined rules. Those rules can be hard to keep track of and update appropriately as the app gets more complex. A recent major incident was reported wherein remote unauthenticated users were allowed to read or write to arbitrary database tables in Lovable apps; Lovable disputed the framing of the incident, saying it was not an incident with Lovable but with apps built with Lovable. Meaning, it’s not their problem if randos can read your data, it’s yours.
- Replit leans a different direction, relying on a centralized application server to manage authorization logic. Centralization can lead to simplified, and therefore more robust, authorization, when done correctly. But many times the application server moves authorization responsibilities to the endpoints, increasing the management surface and leading to similar holes. Even if you know precisely what auth each endpoint should have, the agent has to be fastidious in applying and maintaining those rules as it builds.
- Base44 handles authorization schemes as admin settings that you manage in your account. That takes away your control over much of it — instead of managing access with code that you control, you have to make sure to manually lock down app visibility and per-entity access. So when a customer asks whether one account can reach another’s records, there’s no file in your repo that answers it — somebody has to open the settings and check, entity by entity.
What an AI app security audit covers, item by item
What we check
- Access rules and tenant isolation
- Authentication and session handling
- Secrets and keys
- Backend endpoints and authorization
- Third-party service configuration
- Dependencies
- Data exposure in errors and logs
What you get
After your audit is complete, you’ll receive the findings in a personalized website report as a high-quality artifact built around your application. It gives you:
- A clear overview of your application and how it's built, so that you can see the blueprint for your application
- Every finding ordered by severity, so the most important issues are impossible to miss
- Critical findings clearly labeled and explained in real human language
- Suggested fixes for issues where the fix is known
- Suggestions for compliance and accessibility risk mitigation
What it does for you
You’ll know exactly what’s wrong with your application and what could go wrong if it stays broken. Because every finding is ranked by severity, you won’t waste time guessing what to fix first, the report can be used as your mitigation roadmap. And because most findings come with a fix attached, you’ll have what you need to get your application production ready. With the report in hand you can choose to tackle fixes yourself or hand the report to a developer to resolve.
What it costs
Here is the whole visible market, so you can see where any quote you get actually sits.
$0
Your platform's own scan, plus free third-party scanners
Automated checks against known patterns. Run yours before paying anyone — see the table above for what each platform covers.
$19–$199
Automated report products
The same class of check as free, packaged into a report. Still nobody reading your code.
$499
Fixed-price human review - Aspen Automation
A person reads the code and writes up what they find. Aspen: one week, prioritized findings.
$2,000–$15,000+
Agencies, per the published roundups
Broader scope, longer engagement, bigger project to manage.
Quoted per engagement
Penetration test
Someone actively attacking a running system. Usually a different thing than what you were asked for — see §8.
Scan, audit, or penetration test: which one are you being asked for?
We’ve already talked about the differences between scans, audits, and penetration tests, and we’ve talked about what the different platforms give you for free. If you’re wondering which you need, ask yourself if you’re looking for:
- Automated checks that pre-defined rules are being followed
- Thorough, manual review of your source code, infrastructure, architecture, authentication and authorization scheme, etc etc
- A real thorough beating of your app to prove your security is up to snuff for real attacks
If you answered 1, you’re looking for scans, and the built in scans that your platform provides may very well be sufficient. If you’re interested in 2, you want an audit. And if you need 3, you want a proper penetration test.
Meanwhile, if you’ve actually received a documentation request from a customer, insurance agent, or investor who is interested in your security posture, the best thing to do is dive into the motivation behind the request. Check out our writing on this question in answering a security questionnaire.
So what’s the plan?
Security Agents and scans found in the major AI code platforms are an excellent resource. If your app is pretty simple, stick with that and you should do great. But when you’re prepping your app for a wider audience or more robust features, even the platforms themselves recommend getting a professional to peek under the hood. Our Know Your App audit gives you both the piece of mind of knowing a team of software professionals has done your due diligence, and an action plan to resolve any issues or just grow the way you want. Our audit is available for a fixed fee of $499, takes just one week, and is built by a human software engineer.
$499 fixed price · 1 week
Book an AuditCommon questions
- Does my platform's built-in security scan count as a security audit?
- That’s a no from me dog. They are excellent development tools, and should be used as often as your platform allows. But they are limited, and do nothing to help you understand the holistic security status of your application. A proper security audit will be much more thorough, crossing the boundaries of just your platform to ask questions about your app's entire security posture across all your integrations, your business logic, your architecture, etc etc. All things a scan simply can’t process.
- Do I need a security audit if my AI-built app has no customers yet?
- Probably not. If your app is a small prototype used only by you or a handful of colleagues, you’re fine with the built-in scans your platform provides. Consider a security audit if you plan to handle sensitive user data, are in an industry with strict compliance requirements, or handle real payments.
- How much does an AI app security audit cost?
- $499 from your friends at Aspen Automation
- Can I just ask the AI to audit its own code?
- Your vibe coding platform’s own review, where available, is worth running and does find real things. But these agents are limited in their scope, and the companies have a bias towards their own way of doing things. If you’re concerned about, say, your app’s foundational architecture, you may want to understand all its pros, cons, and alternatives. That’s a difficult request to make of an agent biased towards that architecture and lacking insight into your application’s full business context and additional integrations.
- What if the audit finds nothing?
- Then you’ll receive a report saying so, which you can hand off to whoever asked. But, trust me, there isn’t a piece of software anywhere in the world without something. Even a Ferrarri needs an oil change sometimes.