Vibe coding security risks: a pre-launch checklist
Vibe coding security risks show up at publish time. Learn why apps get exposed and run a pre-launch checklist covering login, data access and secrets.
On this page
- What happened with 35,000 exposed Grok apps
- Why publishing is where vibe coding security risks begin
- Are AI-built apps secure by default?
- Vibe coding security checks to run before launch
- AI app builder security checklist for launch day
- Who should own app security in a small team
- Build it with FromScratch
- FAQ
Vibe coding security risks tend to surface after the app is already live. Building with a chat-based tool feels like the hard part, but a finished app can be reachable by anyone who finds its address. A recent report about more than 35,000 AI-built business apps shows how an ordinary publishing step can expose private data. This guide explains what happened and gives you a checklist to run before you publish your own app.
What happened with 35,000 exposed Grok apps
According to PYMNTS.com, cybersecurity firm Claroc reported in a blog post on November 10 that more than 35,000 business applications built with Grok's AI were accessible without authentication. Authentication means proving who you are before you can see something, usually with a login. Without it, the apps were open to anyone who had the link.
The exposed material was not trivial. Claroc reported that the apps held patient information, employee passwords and proprietary corporate records. The findings included internal information from 30 organizations beyond the Grok developer, SpaceXSI, and X, among them six Fortune 500 companies. Examples cited in the report included a sales territory map covering 594 accounts, an intensive care patient's medical information, and a timesheet application that stored passwords in plain text.
Two points matter for an accurate reading. First, the research does not establish that anyone exploited the exposed information. Being reachable is a serious problem on its own, but the report does not claim a breach has been confirmed. Second, Grok representatives did not immediately reply to PYMNTS.com's request for comment, so the platform's side of the story was not available when the article was published.
Why publishing is where vibe coding security risks begin
Building an app and making it public are two separate decisions. You can spend a week describing features, refining screens and testing the logic in a preview that only you can see. Then you press publish, and the app gets a public address. That single action is where a private tool becomes an exposed one.

Building versus publishing
When you build, the risk is mostly about quality: a broken form, a wrong calculation, a confusing screen. When you publish, the risk becomes about access. Who can open the app? Which pages can they reach? What data comes back when they do? Those questions have different answers in a preview than they do on a public URL.
Treat publishing as its own step with its own review. Ask whether the app should be open to the world, shared with a link, or limited to named people. Make that choice on purpose instead of accepting whatever default the tool gives you.
Why a missing login is the usual gap
An app with no login has no concept of "who is this?" Anyone who reaches a page can read whatever that page loads, and anyone who knows the address of a data endpoint can often request the records behind it. Builders often assume that because the URL is hard to guess, the app is private. That assumption fails as soon as a link is shared in an email, pasted in a chat, or indexed by a search engine.
Shadow IT used to mean employees signing up for unapproved software. AI app builders change the picture because employees can now create and publish their own business tools in an afternoon. A sales manager can build a customer dashboard. An operations lead can build an internal database. Each of those tools may hold data that never went through a security review.
Are AI-built apps secure by default?
Not automatically. The Claroc findings concern one platform, and they do not show that every AI-built app shares the same weaknesses. Some apps are built with login, role checks and careful data handling from the start. Others are not. The honest answer is that security depends on what you ask for and what you check before launch.
This is also why "are AI-built apps secure?" is the wrong question to settle once and forget. Ask it about each app you publish. A tool that stores only a public event calendar has a very different risk profile from one that stores employee records or customer contact details.
Vibe coding security checks to run before launch
Before you publish any app, work through these five areas.

Authentication. List every page and every piece of data. Decide which ones require a login, and who gets an account. If the answer is "everyone who has the link," confirm that this is really what you want.
Data access. For each user role, decide what that person can read, edit, export or delete. A staff member may need to see their own timesheets but not the whole company's. An admin may need to manage users but not download every customer record.
Secrets. Passwords, API keys and tokens must never sit in plain text inside an app's data or code. If you need an app to call an outside service, store the key in a secure settings area and confirm that it is not displayed again after saving.
Sensitive content. Do not upload patient records, customer lists or financial files to a tool you have not reviewed. Ask whether the app really needs that data, and whether sample or anonymized data would work for testing.
Ownership. Name one person responsible for each published app. That person decides who has access, reviews changes and removes the app when it is no longer needed.
AI app builder security checklist for launch day
Use this list as a final gate. Each item takes minutes and catches the most common exposures.
- Test while logged out. Open the app in a private browser window with no session. Confirm that protected pages redirect to a login screen and that no records appear.
- Try the data directly. If you can see a data address in your browser's address bar, open it in the private window. Confirm it does not return records to anonymous visitors.
- Clean out test material. Remove test accounts, sample records and placeholder passwords. Replace any "admin/admin" style credentials before publishing.
- Set visibility deliberately. Choose whether the app is private, shared through a link, or fully public. Do not leave this to a default you did not read.
- Keep a record of changes. Save a version before major edits. If a change breaks access rules, you can restore an earlier version rather than trying to repair the damage under pressure.
Should I add login to my app?
If the app holds anything that is not meant for the whole internet, yes. That includes customer details, internal notes, pricing, schedules, employee information and anything personal. A login is not a complete security program, but it is the boundary that stops an anonymous visitor from reading your data. Public content such as a product catalog or a published guide may not need one, but even then you should decide that on purpose.
Who should own app security in a small team
For a small team, security works best when it is part of the build, not an inspection after launch. Decide the rules before the first prompt. Which data may go into AI-built apps? Who is allowed to publish? Who reviews access before a tool goes live?
Keep the rules short enough that people will follow them. For example: no customer personal data in test apps; every published app has a named owner; login is required for any app that holds company information; access is reviewed once a quarter and whenever someone leaves or changes role. Treat an internal tool like any other system that holds company data, because that is what it becomes.
Access also decays over time. When a staff member leaves, remove their account. When a role changes, update their permissions. An app that was safe when it launched can become risky a year later if nobody revisits who still has access.
Build it with FromScratch
FromScratch builds apps from a plain-language description, using a React front-end, a FastAPI back-end and a database. You can ask for login and roles in your first prompt, then test the result in the live preview before you publish. The steps below show how to build an internal team tracker with access rules from the start, and how to check it before going public.
- Start a new project. Sign in on the free plan and create a project. The AI app builder guide explains how the chat-based workflow fits together.
- Describe the app, login and roles together. Paste the prompt below into the chat. Asking for access rules in the first message is easier than adding them after the screens are built.
- Test in the live preview while logged out. Open the preview in a private browser window. Confirm that the app asks for a login and shows no records to an anonymous visitor.
- Check each role. Log in as a staff member and confirm you see only assigned projects. Log in as an admin and confirm you can manage users and roles, and that the access list is accurate.
- Check the settings page. Save a test secret and confirm it is not shown again afterward. If it is, ask the chat to hide stored secrets and test again.
- Refine by chatting. If something is wrong, describe the fix in plain language, such as "require login for every page except the sign-in screen." Each change is saved, so you can compare versions.
- Publish only after the checklist passes. Publish to a public URL or a custom domain once the checks above are complete. For internal tools, many teams keep the app private and skip public publishing altogether.
- Restore if needed. If a later change breaks access rules, restore an earlier version from the version history.
For a step-by-step walkthrough of internal tools, see how to build an internal tool with AI. If you are not sure whether your idea needs login at all, contact the FromScratch team with your use case.
Paste this prompt into the chat:
Build an internal team tracker app where staff log in with their work email, see only the projects assigned to them, and admins can manage users and roles. Store all data in a database and do not show any records to logged-out visitors. Include a settings page where secrets are never displayed after saving, and an admin page that lists who has access.
Before you go live, also review the vibe coding apps review checklist and the pre-launch security guide.
FAQ
Are AI-built apps automatically insecure?
No. The Claroc findings reported by PYMNTS.com concern one platform, and they do not show that every AI-built app has the same weaknesses. The security of an app depends on whether it requires login, how it limits data access and whether secrets are handled safely. Check each app on its own before you publish.
Do I need a developer to secure my app?
Not always, but someone should review it before launch. A non-developer can run the logged-out test, check each user role and confirm that no passwords or keys are visible. For apps that hold sensitive data, such as health or financial records, an outside review is worth considering.
Should I publish an internal tool to the public web?
Usually not. Internal tools hold company information, so keep them private or limit them to named users. Make a public link only when the app is meant for outside visitors.
What should I never put into an app?
Avoid plain-text passwords, unnecessary personal records and API keys you have not secured. If an app does not need a piece of data to do its job, leave it out. Use sample data for testing and remove it before launch.