Vibe Coding Rescue

The Vibe Coding Glossary for Founders: 35 Terms You Need Before Talking to an Engineer

10 min read | Updated September 2026

You built an app by describing it. Now an engineer, a customer or a compliance form is using words you’ve heard but couldn’t define under pressure — RLS, env vars, staging, idempotent, CI. This glossary is the vocabulary a founder needs to talk about a vibe-coded app: what each term means, why it matters to you specifically, and where to read more when it’s the thing currently on fire.

How to use this

Skim the headings. Read the entries that came up in the last conversation you didn’t fully follow. Each one ends with the practical question to ask about your own app.

Where the code lives

Repository (repo)
The folder of your app’s code, tracked by git so every change is recorded and reversible. Builder platforms hide it; production apps need one you own. Ask: is the code in a repo I control? — see moving off the prototype platform.
Git / commit / branch
Git records changes as commits — snapshots you can return to. A branch is a parallel line of work you can throw away. Ask: before this change, did we make a branch we can go back to? This is the first step in what to do when your app breaks.
Pull request (PR)
A proposed set of changes on a branch, shown as a diff so someone can review it before it merges into the main code. The unit of review when you add an engineer alongside AI.
CI (continuous integration)
Automation that runs your tests on every change, before it can be merged. Ask: does anything run automatically to catch a broken change?
Dependencies / packages
Third-party code your app relies on. AI tools add them freely, occasionally invent ones that don’t exist. Ask: when did we last run an audit? (checklist item 13)

Where it runs

Environment (dev / staging / production)
Separate copies of the app for building, testing and real users, each with its own database and keys. Ask: do we have a staging environment, or does every change go straight to customers?
Environment variables (env vars)
Settings and secrets the app reads at runtime instead of having them written in the code — API keys, database URLs. Prefixes like NEXT_PUBLIC_ or VITE_ mean “send this to the browser,” which is fine for public keys and a leak for secret ones. Ask: which of our env vars are exposed to the browser? (leaked keys)
Deploy / build
Turning the code into a running version users can reach. “Reproducible deploy” means anyone can do it from the repo, not just the person whose laptop it works on.
Preview URL
A temporary deployment of a branch so you can try a change before it reaches users. Vercel and Netlify make one per pull request.
Rollback
Returning production to the previous working version. Cheap if deploys are reproducible; impossible if they’re not.

Who can do what

Authentication vs authorisation
Authentication: proving who you are (login). Authorisation: what you’re allowed to touch. AI-built apps almost always have the first and skip the second. Ask: can a logged-in user see another user’s data by changing an ID? (the 5-minute test)
RLS (row-level security)
Database rules that decide which rows each user can read or write — Supabase’s authorisation layer. Off, or set to true, in most AI-generated schemas. Supabase RLS for vibe-coded apps.
Security rules (Firebase)
Firebase’s equivalent of RLS. “Signed in” is not the same as “allowed.” Firebase rules for vibe-coded apps.
Anon key / publishable key vs secret / service-role key
Public keys are designed to ship to the browser and are protected by rules. Secret keys bypass the rules and must stay on the server. Ask: is any secret key in our frontend bundle?
Roles / entitlements
What a user is (admin, member) and what they’ve paid for (free, pro). Must live in the database, written only by the server, never editable by the client. See Stripe in a vibe-coded app.

How it holds up

Tests / test suite
Code that checks the app still does what it should. Its existence is the difference between “it works” being a fact and a claim. Ask: what command runs the tests, and does the AI run it before saying done? (Claude Code guardrails)
Validation (client vs server)
Checking that incoming data is the right shape. In the browser it’s a convenience; on the server it’s security. Ask: if someone bypasses the form, what stops bad data?
Rate limiting
Capping how often something can be called — signup, login, anything that costs money per request. Without it, a script runs your AI endpoint ten thousand times overnight.
Idempotent
An operation that can safely happen twice with the same result. Webhooks and payments must be idempotent because retries and duplicates are normal. Stripe webhooks explains why.
Webhook
A message a service (Stripe, RevenueCat) sends to your server when something happens — payment succeeded, subscription cancelled. Your app’s source of truth for money, if it’s wired right.
N+1 query
Fetching a list, then one more database call per item. Invisible with three rows, the reason your app is slow at fifty users.
Index
A database structure that makes filtering and sorting fast. AI-generated schemas rarely add them; adding one is usually a one-line, 10–100× fix.
Schema / data model
The tables and their relationships — the skeleton of the app. The one thing that decides whether a prototype can be hardened or must be re-spined. Seven schema smells.
Migration
A recorded, repeatable change to the schema. Should be run on staging before production, with a backup you’ve actually restored.

How you’d know

Error tracking / logging / alerting
Tools that record failures and tell a human. Without them, you learn about outages from customers. Ask: if the app broke at 3 a.m., who would find out, and how?
Backup (and restore)
A copy of the data you can bring back. It only counts once you’ve performed a restore and it worked.
Core Web Vitals
Google’s three speed/stability metrics for pages. A ranking tiebreaker and a UX baseline. The 2026 checklist.
Server-side rendering (SSR) / static
Whether the page’s content exists in the HTML before JavaScript runs. Matters for Google and for anyone on a slow connection. Why vibe-coded sites don’t show up on Google.

Working with people

Diagnostic / audit
A short, fixed-scope review that produces a findings list and a verdict. The step before any quote you should trust — the 12-point audit, and what fixing costs.
Harden vs rebuild
Harden: keep the logic, add the missing layer (security, tests, operability). Rebuild the core: redesign the schema, reuse what sits on top. Most vibe-coded apps are the first.
Handoff
Giving an engineer what they need to start on day one: repo, env var list, service invites, key flows, bug list. The 15-item checklist.
Brief
What you send an agency before the first call. A working prototype is a very good one. How to brief a development agency.

If a term you met isn’t here, send it to us — this page gets extended from real conversations.


Heard a term that worried you?

Send us the sentence it came in. A short diagnostic turns “I think we might have a problem with RLS” into a findings list and a plan.

Ask an Engineer →

Engineering Insights

Latest from Syntaxa Studio.

Loading latest posts