What Vibe Coding Means for Your SaaS and Its Customers
A working login screen doesn't prove one customer can't read another customer's records. That's the gap you need to check when AI writes your software.
Vibe coding means describing what you want in plain language and letting AI generate the code. The sharper distinction is what happens next: do you inspect and test the changes, or accept them because the app appears to work?
For a shipped SaaS, that choice affects your customers. It also gives you something more useful to publish than another claim that you built faster with AI.
What does vibe coding mean?
Vibe coding means using plain-language prompts to get AI to build or change software, with less direct control over the code. In its stricter sense, you accept the output without fully reading or understanding how it works.
You might ask an AI tool to add a login page. It writes the code. You open the app, try signing in, and ask for changes until the result looks right.
The tool is doing more than suggesting the next line. You're describing the result and letting it choose how to get there.
For this article, the useful distinction is between two ways of working:
- AI-assisted coding: you ask for code, inspect the changes, and test the behavior before accepting it.
- Vibe coding: you guide the result through prompts and accept changes without fully understanding the code behind them.
Neither description tells you whether a particular app is safe. Reading code doesn't guarantee you catch every bug. Getting a convincing screen doesn't prove the underlying rules work, either.
The distinction tells you where you still need evidence.
If you can explain how the code keeps customer records separate, you can check that explanation against a test. If you can't, the working screen leaves an important question unanswered.
You don't need to write every line yourself to own a product. You do need a way to check the parts that could hurt a customer.
Asking AI to write code doesn't remove your responsibility for deciding whether it should ship. That responsibility starts with knowing what changed, what might fail, and how you'll check it.
Using AI doesn't tell you whether the code was checked
A prompt describes what you want; it doesn't prove the generated code does it safely. Asking for a secure feature and checking that feature are separate jobs.
Suppose you ask an AI tool to add customer accounts to your SaaS. You describe the screens and explain that each customer should see only their own records.
The tool can produce something that matches your request on screen. That still leaves you with questions about how the app handles requests behind the screen.
To check the change, ask:
- Which files changed, and why?
- Where does the server check who made the request?
- Which rule decides whether that person can access a record?
- What happens when the request should be refused?
Treat the tool's explanation as a guide to inspect, not proof that the code works. Ask it to point to the exact check. Then read that check and try to break the rule it claims to enforce.
You don't have to understand your entire codebase before reviewing a small change. You do need to understand the part you're approving, or bring in someone who does.
That gives you a better stopping rule than “the demo looks good.” If you can't explain a risky change, don't keep adding features around it. Reduce the change until you can review it.
For example, ask for the access check alone before accepting a larger rewrite of the account system. A smaller patch gives you fewer moving parts to inspect. It doesn't promise safety, but it makes your next question clearer: does this specific check refuse the request it should refuse?
A working login screen doesn't prove customer records are private
A SaaS login confirms who someone is; a separate access check must decide which records they can read. Those are different questions, even when the app presents them through the same screen.
Consider an illustrative SaaS that stores customer projects. You sign in, create a project, and see it on your dashboard. Everything looks right.
That proves your account can reach its own project through the route you tried. It doesn't establish what happens if you request a project belonging to another account.
Use separate test accounts with clearly different records. Then check the boundary directly:
- Sign in as one customer and open that customer's project.
- Find a project belonging to the other test customer.
- Try requesting that project while signed in as the first customer.
- Confirm the server refuses access and doesn't return the private record.
Run that check through the underlying request, not just by clicking around the dashboard. Hiding a link isn't the same as refusing access to the thing behind it.
Apply the same thinking to changes and downloads. A customer who can't view another account's record shouldn't be able to edit it through a different request.
These are suggested checks for the example, not a claim that every app shares the same bug. Your routes and permissions may differ. The question stays concrete: can this signed-in customer do something with someone else's data that you never intended?
When you publish about the work, describe exactly what you checked. “We tested whether one customer could request another customer's project” says more than “we take security seriously.” It also avoids claiming that one passing test proves the whole product is secure.
Test refused requests and failed payments before release
A SaaS needs checks for actions it should refuse and payments that don't succeed. A successful purchase only shows what happened along one successful route.
For AI-written changes, start with the behavior you promised the customer. Write down what should happen when the request succeeds and when it fails. Use that expected behavior to judge the code.
Access rules and billing deserve separate checks because a correct screen can hide an incorrect decision underneath it.
A focused pre-release check might cover:
- Denied access: a signed-in customer requests a record they don't own, and the server refuses it.
- Failed payment: a payment fails, and the account follows your stated rules for access and payment status.
- Database changes: the new code works with representative existing records, rather than only a fresh account.
Choose the expected result before running each check. Otherwise, it's too easy to accept whatever the app happens to do.
Failed payments need particular care in how you describe the intended behavior. You may want to preserve an existing customer's access for a period. You may want to withhold a new paid feature until payment succeeds. Those are product choices you must make explicitly.
Don't ask AI to invent those choices inside a code change. Tell it the rule, inspect where it applies that rule, and test the result.
Keep a short record of what you tried and what happened. Include failures you fixed, not just passing checks. That record helps you review the next change without relying on your memory.
It can also support useful customer-facing writing. Explain the behavior customers can expect when a payment fails. Leave out private billing details and avoid pretending your test covered cases you haven't checked.
Database changes need a recovery plan
A database change can affect records that existed before the new code, so test it against representative older data. A fresh account won't show you every problem an existing customer might face.
Suppose an AI-generated patch adds a required field to each project. Creating a new project might work because the new form supplies that field. Older projects still need a defined way to handle it.
Before accepting the patch, ask what happens to those older records. Don't settle for an explanation of how new records get created.
Your review should answer:
- What changes in the stored data?
- How will existing records receive any new required values?
- Can the previous app version still read the changed records?
- How will you recover if the change fails partway through?
Try the change away from live customer data first. Use representative records without exposing private information to your tools or your test setup.
Then walk through an existing customer's ordinary task. Open an older project. Edit it. Save it. Check whether the values still mean what they meant before the change.
A recovery plan needs more detail than “we have a backup.” Decide who will stop the release, what they'll restore, and how they'll check the result. If you're the only operator, write those steps for yourself before you're dealing with a broken product.
You can ask AI to help draft the plan. You still need to verify that the steps match your actual database and release process.
For public content, an honest explanation of an upgrade check can be useful. Show a made-up record that represents the older format. Explain the problem you were trying to avoid and the check you added. Don't publish customer records to make the example feel more convincing.
How do you review AI code you don't understand?
Ask for a smaller patch, inspect it, and test one clearly stated behavior before merging. If a change still exceeds your understanding, get a qualified reviewer rather than accepting the AI tool's reassurance.
A large patch makes it harder to see which change caused a problem. It can also mix a necessary fix with unrelated cleanup, leaving you more code to judge at once.
Give the tool a narrower request. For the customer-record example, that could be:
Change only the server-side check for reading a project. Explain how it checks the signed-in account against the project owner. Add a test that refuses another account's request. Don't rewrite unrelated code.
The wording isn't a safety guarantee. It's a way to make the proposed work easier to inspect.
Before merging, check three things:
- The change: can you explain what the patch does without repeating the tool's answer word for word?
- The test: does it check the behavior you care about, including a request that should fail?
- The boundary: did the patch change anything outside the task you asked it to handle?
If an explanation stays vague, ask the tool to identify the exact function and condition. If the code still doesn't make sense, pause the release.
Use the same care around secrets. Check that a proposed change hasn't put a private key into code sent to the browser or into an example you're about to publish.
You can keep using AI throughout this process. Ask it to explain unfamiliar syntax or suggest ways a test might miss a bug. Just don't let the same confident answer replace every independent check. The decision to merge still belongs to you.
What should you publish about a vibe-coded product?
Publish the problem you checked, the test that exposed it, and the fix you made. That gives a reader something concrete to judge without asking them to trust a broad claim about your product.
If you've shipped a SaaS and have little time to write, use work you're already doing. A small, well-explained check can become a useful article without turning your week into a writing project.
For the customer-record example, save a short note while the details are fresh:
- The risk: a customer must never receive another customer's project through a direct request.
- The check: use separate test accounts and request the other account's record.
- The result: record what actually happened, including whether the test passed before any fix.
- The change: if you found a bug, explain what you changed and rerun the check.
Don't manufacture a failure because a bug story sounds more interesting. A passing check is still worth explaining if it answers a real buyer's question.
Keep the claim narrow. A test that checks one route doesn't prove every route is safe. A fixed access bug doesn't prove the product has no other bugs. Say what you checked and where the check stops.
Remove secrets and customer details before publishing. Use test accounts and clearly label illustrative examples. Readers should be able to tell the difference between a real finding and a suggested way to test their own app.
Your next article doesn't need to be a grand story about building with AI. Pick one risky change from your next release. Write down the expected behavior, test the failure case, and save the result. Then publish what you can actually show.