Every term you'll hit while building apps with AI. From context windows to deployment — explained in plain English for vibe coders.
111 terms, plain English, no gatekeeping. Search it, skim it, come back to it.
Automation that tests your code and ships it every time you push a change.
Removes the manual step of deploying. Push to GitHub, tests run, and your app updates automatically.
The skill of writing effective prompts to get the best possible output from AI tools.
Structure and specificity matter more than fancy wording. The best prompt engineers think like product managers — clear requirements, clear constraints.
An error in your software that makes it behave in a way you didn't intend.
Bugs aren't failure, they're feedback. The useful skill is describing exactly what you expected versus what happened — that's what lets AI fix it fast.
A set of tools and rules for building apps faster — like React, Next.js, or SwiftUI.
A framework gives you structure. A library gives you a tool. Frameworks are opinionated — they tell you how to organize your code.
When you've built something a specific group of people genuinely want and pay for. The thing every founder is chasing.
You'll know when you have it — people complain when it's down, tell their friends, and keep coming back.
The amount of text an AI can 'see' at once — your prompt, the chat history, and any files it's reading.
Every model has a limit. When you hit it, the AI starts forgetting earlier parts of the conversation and responses get sloppy.
A technique where AI looks up real data from your files or database before answering, reducing hallucinations.
Instead of guessing from training data, the AI retrieves actual information first. Essential for apps that need accurate, up-to-date answers.
Code that anyone can read, use, and contribute to. The backbone of modern software.
Most of the tools you use for vibe coding are built on open source.
Working on both frontend and backend. A full-stack builder can wire up the whole thing.
Vibe coding is making full-stack more accessible. You describe what you need on both sides and the AI builds it.
The live version of your app that real users interact with.
Treat production as sacred. Test in preview, and never experiment on the version your users are actually touching.
How much you spend on average to get one paying customer.
Healthy when your LTV is at least 3x your CAC. If you're spending more to acquire than you earn, you have a problem.
A snapshot of your code at a point in time, with a message describing what changed.
Good commit messages are like breadcrumbs. When something breaks, they tell you exactly when and why.
The kind of AI behind ChatGPT, Claude, and Gemini. Trained on huge amounts of text to predict the next word.
Different LLMs have different strengths. Some are better at code, some at reasoning, some at creative writing. Picking the right one matters.
A tool that tracks every change to your code so you can undo, branch, and collaborate without overwriting each other.
Even solo builders need Git. It's your safety net — you can always go back to a version that worked.
Reverting a deploy to the previous working version when something breaks in production.
Your safety net. Knowing you can undo a bad deploy in one click is what makes shipping often feel safe instead of scary.
A rough sketch of a screen showing layout and structure, no styling. Used to agree on the bones before designing.
Five minutes of sketching prevents an hour of re-prompting. Decide the structure before you invite AI to make it pretty.
The smallest version of your idea that still solves the core problem. Ship it, learn, iterate.
Perfectionism kills apps. An MVP that's live and getting feedback beats a polished app still on your laptop.
A copy of your live app where you test changes safely before pushing them to real users.
Breaking things in staging is fine. Breaking things in production is not.
How your app makes money — subscriptions, one-time purchases, ads, affiliate, or a mix.
Decide how it makes money before you build it. Bolting pricing onto a finished free product is much harder than designing for it.
To repeat a process and improve each time. Small changes, tested and refined, compound into big results.
Vibe coding is iteration. Your first prompt is never the final answer — ship something rough, look at it, then fix one thing at a time.
The website where most people store their Git repositories. Think Google Drive for code.
Even solo, use it. It's your backup, your undo history, and how hosting platforms deploy your app automatically.
The percentage of users who cancel each month. Low churn means people stick around.
Growth means nothing if churn is high — you're refilling a leaky bucket. Ask leavers why; the answers are usually fixable.
Pushing your app from your computer to the internet so other people can use it.
With modern tools like Vercel or Netlify, deployment can be as simple as pushing code to GitHub.
A setting that controls how creative or predictable AI output is. Low = safe and consistent. High = wild and varied.
For code generation you usually want low temperature. For brainstorming or creative writing, turn it up.
Your own copy of someone else's project that you can change freely without affecting the original.
The polite way to build on someone else's open-source work — and a safe way to learn by taking apart a real project.
A parallel version of your code where you can experiment without breaking the main one.
Build risky changes on a branch. If it turns out badly you throw the branch away instead of untangling your main app.
The path a user takes through your app to complete a task — sign up, buy, check out.
Map the flow end to end before building. Missing steps — confirmations, empty states, errors — are what make apps feel unfinished.
A detailed description of your perfect customer — who they are, what they need, and why they buy.
Being specific feels limiting but makes everything easier — copy, features, pricing. Vague audience, vague product.
The first experience a new user has. Where most apps lose people if they're not careful.
A confusing onboarding kills retention. Keep it short, show value fast, don't ask for too much upfront.
A proposal to merge changes from one branch into another. Where code review happens.
Even without a team, a PR gives you a readable summary of what changed before it goes live — and a place for AI review.
Free core version, paid upgrade for more features or higher limits. Common for indie apps.
Works when the free tier shows real value but hits a natural limit. It fails when free is either useless or too generous.
A standard that lets AI tools connect to outside services (databases, APIs, your files) in a consistent way.
Think of it as USB-C for AI tools. One protocol, many connections. Build once, plug into anything.
Running backend code without managing a server. The cloud provider handles scaling and uptime for you.
You still have servers — you just don't think about them. Your code runs on demand and you pay per use.
The predictable monthly income from your subscriptions. The number SaaS founders watch most.
The clearest signal of whether your product is working. One paying customer teaches you more than a thousand visitors.
Data your app remembers right now — what's typed in a field, which tab is open, who's logged in.
Most confusing UI bugs are state bugs — something remembered when it should have reset. Say what should reset and when.
Custom instructions you give Cursor so it understands your project's patterns, stack, and preferences.
A well-written rules file is the difference between Cursor fighting you and Cursor feeling like a teammate who gets your codebase.
Optimizing your app's title, keywords, screenshots, and description to rank higher in App Store search.
Like SEO but for the App Store. The right keywords and screenshots can make or break your organic downloads.
An external library or package your project needs to work. Listed in your package.json or similar file.
More dependencies = more things that can break when they update. Keep it lean.
The format APIs use to send data back and forth. Looks like a list of key-value pairs.
You'll see JSON everywhere — API responses, config files, data storage. It's the universal language of web data.
A specific URL on an API you can call to get or send data, like /users or /orders.
When an integration breaks, checking the exact endpoint and what it returns is usually the fastest way to find the problem.
Showing two versions of something to different users to see which one performs better.
Only worth it once you have real traffic. Before that, talk to five users — you'll learn more, faster.
A standard for letting users log in with their Google, Apple, or GitHub account instead of creating a new password.
Fewer passwords means fewer signup drop-offs and less for you to secure. Add social login before you build a password reset flow.
How much revenue an average customer generates over the whole time they stay with you.
Compare it to what it costs you to get a customer. If acquisition costs more than lifetime value, growth makes things worse.
A strategy where the product itself drives sign-ups and growth, not a sales team.
The natural fit for indie builders — no sales team. It requires the product to explain and sell itself in the first minute.
A shared library of colors, fonts, spacing, and components so your product looks consistent everywhere.
Define your colors, fonts, and spacing once. It's what keeps an AI-built app from looking like five different apps stitched together.
Where your app stores information that needs to stick around — users, posts, orders.
Supabase, Firebase, and Planetscale are popular options. They handle the heavy lifting so you focus on the product.
Apple's tool for letting beta testers install your iOS app before it goes on the App Store.
Essential for iOS development. Get real people using your app and catching bugs before the public launch.
Training a model further on your own data so it specializes in a task or style.
Most vibe coders won't fine-tune models directly. But understanding it helps you pick the right tool for the job.
A password that lets your app use a third-party service. Keep it secret — never paste it in your frontend code.
The single most common vibe-coding security mistake is a key pasted into frontend code. Keys belong in server-side environment variables only.
Building software by describing what you want in plain English and letting AI write the code. You drive with intent and taste, not syntax.
You don't need to understand every line the AI writes. You need to understand what you're building and why. The AI handles implementation — you handle direction.
Sharing your progress, numbers, and lessons publicly while you build. Distribution and trust as a side effect.
Not about bragging. It's about showing the real process — what worked, what failed, what you learned.
Code that runs between a request coming in and your app responding. Used for auth checks, logging, redirects.
The right place for rules that apply everywhere — 'must be logged in', 'log this', 'redirect that' — instead of repeating checks on every page.
A clickable version of your design used to test the flow before you write real code.
Test the flow on one real person before building it properly. Confusion shows up in seconds and saves weeks.
Proving who a user is — usually with email and password, magic link, or social login.
Never hand-roll it. Use a proven provider — auth is the one area where a clever shortcut becomes a security incident.
A short description of a feature from the user's perspective: 'As a ___, I want ___ so that ___.'
Keeps you focused on the user's problem instead of jumping to solutions. Write these before you build.
Push sends your local changes up to GitHub. Pull brings down changes others made.
Pull before you start working, push when you finish. That rhythm prevents most of the confusing conflicts beginners hit.
What the user sees and interacts with — colors, layout, buttons, typography.
UI is where taste shows. AI can produce a competent screen instantly, so your value is in judging what to change.
Rewriting code to make it cleaner or faster without changing what it does.
Do it when a file gets scary to change. Refactoring buys you speed later, but never refactor and add a feature in the same step.
How it feels to use your product — clarity, flow, friction. The full journey, not just looks.
Good UX is mostly removing steps. Before adding a feature, ask whether deleting something would fix the problem instead.
A static, fully styled picture of what a screen will look like. No interactivity yet.
Handy as a reference to hand your AI: 'build this screen' with an image attached beats a long written description.
Reusable code someone else wrote that you can drop into your project to skip writing it yourself.
Every library is also a liability you have to update. Prefer a few well-maintained ones over a pile of tiny abandoned ones.
A tool that installs, updates, and manages your project's dependencies. npm, yarn, and pnpm are the common ones.
Pick one and stick to it. Mixing npm and yarn in the same project is a classic source of mysterious build failures.
A reusable piece of UI — a button, a card, a header — you build once and use everywhere.
Thinking in components makes AI requests sharper: 'change the card component' is far more precise than 'change the page'.
Capping how many requests a user or app can make in a time window. Protects your API from abuse and overload.
Add it to anything that costs you money per call, especially AI features. It's the cheapest protection against a surprise bill.
To release your product to real users. Getting it out into the world.
Shipping is a muscle. The more you do it, the less scary it gets. Done is better than perfect.
The padlock in the browser bar. Encrypts data between your user and your site so it can't be snooped on.
Non-negotiable. Browsers warn users away from sites without it, and modern hosts give it to you automatically for free.
A tracked note in a repo describing a bug, feature request, or task to do.
Your project's memory. Write the bug down the moment you notice it, or you'll rediscover it after launch.
Auto-generating the basic file structure and setup code for a new project or feature.
Great for consistency — the structure is right from the start, so AI has a clean pattern to follow when adding the next feature.
A design that adapts and looks good on any screen size — phone, tablet, desktop.
Most of your visitors are on a phone. Check mobile first, not last, or you'll ship something that only looks right on your laptop.
The unit AI models use to read and generate text. Roughly 4 characters or three-quarters of a word in English.
AI usage is priced per token. Bigger files and longer chats burn more tokens — which means higher costs and slower responses.
Running a trained AI model to get output. Every time you prompt Claude or ChatGPT, that's inference.
Training builds the model. Inference uses it. You pay for inference every time you make an API call.
Starter code or templates that give you a working foundation so you don't build everything from scratch.
Starting from boilerplate saves days, but only if you understand roughly what's in it. Otherwise you inherit someone else's decisions blindly.
An AI that can take actions on your behalf — read files, run commands, edit code — not just chat back.
Agents don't wait for you to copy-paste. They operate in your environment, make decisions, and execute. Cursor and Claude Code work this way.
Software you pay for on a subscription instead of buying once. Think Notion, Figma, Spotify.
The default model for vibe-coded products: build once, charge monthly, improve continuously.
Having someone (or an AI) read your code before it merges — catching bugs and sharing context.
Asking AI to review its own output catches surprising amounts of sloppiness. A second pass costs a minute and saves hours.
A small urgent fix shipped straight to production to patch a live problem.
Useful in a real emergency, risky as a habit. Always circle back and fix the root cause properly afterwards.
Deciding what a logged-in user is allowed to do. Different from authentication.
Auth = who are you. Authorization = what can you do. You need both for any app with user accounts.
How many months your business can keep running before it runs out of cash.
Know your number. Runway decides whether you can build the ambitious version or need something earning money this month.
A service that gives you a ready-made backend — database, auth, storage — so you don't build it yourself. Supabase and Firebase are examples.
The reason vibe coders can ship full apps fast. BaaS handles the infrastructure so you focus on the product.
Giving AI the right files, docs, and instructions so it has what it needs to do the job well.
The model is only as good as what you feed it. Context engineering is about curating the right input — not just writing a good prompt.
A computer connected to the internet that runs your backend code and serves data to users.
With modern hosting you rarely manage one yourself, but knowing code runs somewhere else explains why some things are slow or fail intermittently.
A folder containing your project's code and its full history of changes.
One project, one repo. The history is what lets you go back to the last version that worked when a change goes wrong.
A network of servers around the world that serves your images and files from the location closest to each user.
Free speed. Serving images through a CDN is often the biggest performance win available for the least work.
A secret value (like an API key) stored outside your code so it doesn't leak into GitHub.
Every deployment platform has a place to store these. If you paste an API key directly in your code, it's exposed.
The detective work of finding and fixing bugs — reading errors, testing assumptions, tracing what went wrong.
AI tools are great at debugging. Paste the error, give context, and let the AI trace the problem.
AI that doesn't just suggest code but takes actions autonomously — reading files, running commands, fixing errors in a loop.
The difference between a chatbot and an agent. Agentic coding tools can chain multiple steps together without you intervening at each one.
The instructions you give an AI. The clearer and more specific your prompt, the better the result.
A good prompt includes context, constraints, and examples. Think of it as a brief for your AI — garbage in, garbage out.
An automatic message one service sends another when something happens — like Stripe pinging your app when a payment succeeds.
Webhooks are how your app reacts to the outside world in real time. Always verify the sender — an unverified webhook is an open door.
The hidden instructions that shape how an AI behaves before you say anything. Sets the tone and rules.
Every AI tool has one. It's why Claude sounds different from ChatGPT out of the box. You can write your own to customize behavior.
A pricing model where users pay on a recurring schedule — monthly or yearly — for ongoing access.
Recurring revenue is predictable, but it also means you have to keep earning it every month with real ongoing value.
Code that runs on servers close to your users around the world, making responses faster.
Vercel, Cloudflare, and Supabase all offer edge functions. Great for auth checks, redirects, and quick API logic.
The part of your app users see and click — the screens, buttons, and layout.
When you say 'this button should be over there', you're talking about the frontend. Being specific about visual intent gets far better AI output.
A way to turn text into numbers so computers can compare meaning and find similar things.
Used behind the scenes in search, recommendations, and RAG. You describe something in words, embeddings let the AI find related content.
The phonebook of the internet. Translates your domain name into the server address that actually serves your site.
When your site 'isn't live yet' after buying a domain, it's usually DNS still propagating. Give it a few hours before assuming you broke something.
When an AI confidently makes up something that isn't true — a fake function, a wrong API, a non-existent library.
This is why you always verify what AI gives you. It sounds right, it looks right, but it might be completely invented.
Your app's address on the internet, like ninakolari.com. You buy it from a registrar.
Buy the domain early, even before the app is done. It costs about the price of a coffee and makes the project feel real.
The process of bundling your code into the optimized files that get served to users.
If your app works locally but breaks after deploy, the build is usually where to look — a missing dependency or environment variable.
When an AI agrees with you instead of telling you the truth. It wants to please you, even when you're wrong.
A common failure mode. The AI says 'great idea!' when it should say 'that won't work.' Push back and ask it to challenge your assumptions.
Your own computer acting as a server while you develop. The app runs locally before you deploy it anywhere.
Working locally means you can break things freely. If it works locally but not live, the difference is usually environment variables.
Apple's process of approving your app before it can be published. Usually takes 24-48 hours.
Your app can be rejected for guideline violations. Read the rules before you submit.
Combining changes from one branch into another.
Most conflicts happen when two changes touch the same lines. Merge often and in small chunks to keep it painless.
When Git can't auto-combine two changes to the same line and needs you to pick which one wins.
Sounds scary, looks messy, but it's just Git asking you to make a decision. AI tools can help resolve these.
Designing your product so people with disabilities can use it — proper contrast, labels, keyboard navigation.
Not optional. Good accessibility makes your product better for everyone.
The part users don't see — servers, databases, business logic, and APIs that power the frontend.
If the change involves saving, sending, or securing data, it's a backend change — and it needs more care than a visual tweak.
A temporary store of data so your app doesn't have to fetch the same thing twice. Faster, cheaper.
Caching makes apps feel instant, but it's also why you sometimes still see the old version after a deploy. Hard-refresh before panicking.
A pre-built library that makes it easier to use someone else's API or platform.
If an SDK exists for the service you're using, use it. It handles the fiddly parts — auth, retries, types — you'd otherwise get wrong.
Your MRR multiplied by 12. The yearly view of subscription income.
Mostly used for comparing and fundraising. Day to day, MRR and churn tell you more about health.
The service that runs your app on the internet — like Vercel, Netlify, or Cloudflare.
You don't need to understand servers. Pick one host, connect your repo, and let it deploy on every push. Switching later is easy.
The date after which a model has no training data. It doesn't know about anything that happened after that point.
This is why AI sometimes suggests outdated libraries or deprecated APIs. If it was trained before a tool existed, it literally can't know about it.
The future cost of quick-and-dirty code. Useful to ship fast, painful if you never clean it up.
Every vibe coder accumulates tech debt. The trick is knowing when to pay it down and when to keep shipping.
A way for two pieces of software to talk to each other. Your app uses APIs to ask other services for data or actions.
When your app checks the weather, processes a payment, or sends an email — it's calling an API.