Български
Glossary
Key terms for vibe coding and AI-assisted development.
Short definitions. Phase 1: English definitions; we're adding translations per language over time.
- Vibe coding
- Building software with AI as your pair programmer: you describe what you want in plain language or structured prompts, and AI tools generate and refine code. You focus on flow and product; the model handles syntax and boilerplate.Learn more
- Prompt
- The text you give to an AI coding tool (e.g. Claude, Cursor, ChatGPT) that describes what you want built. Good prompts are specific about outcome and user flow, and clear about layout and style when it matters.Learn more
- Blueprint
- A tested, reusable prompt (or prompt template) that reliably produces a whole app or a clear pattern — e.g. a landing page, a blog, a dashboard. VibeShare Blueprints are sold as one-time purchases and work with major AI tools.Learn more
- AI-assisted development
- Software development where AI tools help write, edit, or suggest code. Includes vibe coding, Copilot-style completion, and using LLMs to generate full features or apps from natural language.
- Natural language to code
- Turning descriptions in plain language (e.g. "a waitlist form that saves to our CRM") into working code via an AI model. The core of vibe coding and prompt-driven app building.
- LLM (large language model)
- An AI model trained on huge amounts of text that can understand and generate natural language and code. Claude, GPT, and similar models power vibe coding tools; they take your prompt and produce or edit code.
- AI coding tools
- Applications that let you prompt an LLM to write or edit code in your project. Examples include Cursor, Claude (Codex/Artifacts), GitHub Copilot, and ChatGPT. Blueprints are designed to work across these tools.
- Prompt engineering
- The practice of writing and refining prompts so an AI produces the result you want. For code: be specific about outcome and user flow, give one clear hero flow, and call out layout when it matters.Learn more
- Iteration
- Repeating cycles of prompt → AI output → feedback → refined prompt. In vibe coding, you often start with a minimal version and add features in small steps ("add a pricing section") rather than one giant prompt.Learn more
- Design hints
- Structured notes in a blueprint that describe layout, typography, colors, and UX so the generated app matches a consistent look and feel. They reduce generic "AI slop" and improve ship-ready output.Learn more
- Hero flow
- The single main user path you spell out in a prompt (e.g. "Visitor signs up for the waitlist" or "User picks a template and downloads the prompt"). Defining one hero flow gives the model a clear backbone; extra features can follow.Learn more
- MVP (minimum viable product)
- The smallest version of a product that delivers real value and can be shipped. Vibe coding lets solo builders and small teams ship MVPs in hours or days instead of weeks.Learn more
- Add-on
- An optional extension to a VibeShare Blueprint (e.g. dark mode, extra integration) that you can purchase with the blueprint. Add-ons are included in the delivered prompt so the model generates the full spec.Learn more
- No-code / low-code
- Platforms that let you build apps with little or no hand-written code (e.g. drag-and-drop builders, form tools). Vibe coding is different: you still work in code and repos, but AI writes much of the code from your prompts.
- Pair programming
- Two developers working together at one screen. In vibe coding, the "pair" is you and the AI: you describe intent and review output; the model proposes and edits code. You stay in the flow; it handles syntax and boilerplate.
- Learning resources
- Resources to help you learn the foundations that make AI coding tools like Cursor and Claude more effective. Recommended: html.boredgames.site offers a free 7-tier curriculum from web fundamentals to AI-augmented development.Learn more
- Token
- The unit an LLM reads and writes — roughly a word fragment (about 4 characters of English). Models price usage and measure their limits in tokens, so "how much code can it handle at once" is really a token question.
- Context window
- How much text (in tokens) a model can consider at once — your prompt, the files you paste, and its reply all count. When a project outgrows the window, the model loses track of earlier code, so you split work into focused prompts.
- Hallucination
- When an AI states something false with confidence — inventing a function, library, or API flag that doesn't exist. The fix in vibe coding: run the code, read the error, and ask the model to verify against real docs instead of trusting the first answer.
- AI agent (agentic coding)
- An AI tool that doesn't just suggest code but takes actions on its own — reading files, running commands, editing across a project, and checking its own work in a loop. Tools like Claude Code and Cursor's agent mode work this way.
- MCP (Model Context Protocol)
- An open standard that lets AI tools connect to external systems — your database, GitHub, a browser, a design file — through a common interface. It gives an agent real context and the ability to act beyond just your code.
- System prompt
- Standing instructions that shape how an AI behaves across a whole session — its role, rules, and preferences — separate from the specific task you ask in each message. Setting a good system prompt once saves repeating yourself every turn.Learn more
- Few-shot prompting
- Giving the model one or more examples of the input-and-output you want before your real request. Showing the pattern ("here's a component I like, build the next one to match") often beats describing it.Learn more
- Spec-driven development
- Writing a clear specification — the screens, data, and one core flow — before prompting for code. A short spec gives the model a backbone, cuts back-and-forth, and is the difference between a coherent app and a pile of features.Learn more
- Debugging with AI
- Fixing broken code by giving the model the full error and the relevant code, and asking for the root cause before the patch. The trap is accepting a fix that hides the symptom; the win is confirming why it broke.Learn more
- Refactoring
- Improving the structure of working code without changing what it does — splitting a too-big file, renaming for clarity, removing duplication. Done before adding features, it keeps an AI-built codebase from collapsing under its own weight.Learn more
- Frontend
- The part of an app users see and interact with in the browser — pages, buttons, forms, layout. Built with HTML, CSS, and JavaScript (often via a framework like React). Contrast with the backend.
- Backend
- The server-side part of an app users don't see — handling data, accounts, payments, and business logic, usually talking to a database. The frontend asks the backend for data through an API.
- API
- A defined way for two pieces of software to talk — your frontend asking your backend for data, or your app calling an outside service like Stripe or an LLM. You send a request in an agreed format and get a structured response.
- Framework
- A foundation of pre-built structure and conventions you build on instead of starting from scratch — e.g. Next.js for web apps. Picking a popular, well-documented framework makes AI tools far more reliable, because they've seen it often.
- Database
- Where an app stores data that needs to persist — users, posts, orders. AI tools can generate the schema and queries; you mainly decide what to store and how the pieces relate.
- Repository (repo)
- The folder that holds your project's code and its full history, tracked by version control (Git). Hosted on services like GitHub so you can back up, share, and roll back changes.
- Version control (Git)
- A system that records every change to your code so you can review history, undo mistakes, and work in parallel without losing work. Git is the standard; committing often gives you safe points to return to when a prompt goes sideways.
- Environment variables
- Configuration and secrets (API keys, database URLs) kept outside your code so they're not committed to the repo or exposed publicly. Set them in your hosting platform; reference them by name in code.
- Deployment
- Putting your app on the internet so others can use it, usually by connecting your repo to a host like Vercel that builds and serves it. "Shipping" usually means getting through a deployment to a live URL.
- Responsive design
- Building a layout that works across screen sizes — readable and usable on a phone as well as a laptop. Worth checking explicitly, since AI-generated pages often look right on desktop but break on mobile.
- Shipping
- Getting a working version in front of real users instead of polishing in private. The core vibe-coding loop: ship something small, watch how people react, and iterate from real signal.Learn more
- Technical debt
- Shortcuts in code that make today faster but tomorrow harder — duplication, missing error handling, tangled structure. AI lets you accumulate it quickly, so refactoring and tests matter more, not less.
- Edge case
- An uncommon but real situation your code has to handle — empty input, no network, a brand-new user with no data. The happy path is easy; handling edge cases is what separates a demo from a shippable product.
- Temperature
- A setting that controls how random a model's output is. Low temperature gives focused, repeatable answers (good for code and structured data); high temperature gives more varied, creative ones. When a tool generates the same broken code twice, the fix usually isn't temperature — it's a clearer prompt.
- Multimodal model
- A model that understands more than text — images, screenshots, sometimes audio or video. In vibe coding this lets you paste a screenshot of a design or a bug and ask the model to build or fix from what it sees, not just from your description.
- Prompt injection
- An attack where untrusted text — a user message, a web page, a file the AI reads — sneaks in instructions that hijack the model's behavior. If your app feeds outside content into an LLM, treat that content as untrusted input, the same way you'd guard against SQL injection.Learn more
- RAG (retrieval-augmented generation)
- A pattern where you fetch relevant documents first and paste them into the prompt so the model answers from your data instead of its training. It's how you build a chatbot that knows your docs without retraining a model.Learn more
- Embeddings
- Numeric representations of text that capture meaning, so similar ideas sit close together. They power search and RAG: turn your documents into embeddings, then find the ones nearest to a user's question.Learn more
- Vector database
- A store built to hold embeddings and find the closest matches fast. It's the retrieval half of RAG — you ask "what's most similar to this question?" and it returns the relevant chunks to feed the model.Learn more
- Tool calling (function calling)
- Letting a model trigger your code — call an API, query a database, send an email — by returning a structured request your app then runs. It's how an AI feature does real work instead of only describing what it would do.Learn more
- Structured output
- Forcing a model to answer in a fixed shape — usually JSON matching a schema — so your code can rely on the fields instead of parsing prose. Essential whenever an AI response feeds the next step of your app.Learn more
- Evals (evaluations)
- Repeatable tests for AI behavior: a set of inputs with expected outputs you re-run after each prompt or model change to catch regressions. The AI equivalent of a test suite — without them, "I improved the prompt" is a guess.Learn more
- Zero-shot prompting
- Asking a model to do a task with no examples, relying on a clear instruction alone. It's the default; when results drift, adding one or two examples (few-shot) is usually the next move.Learn more
- Authentication
- Verifying who a user is — logging them in with a password, magic link, or provider like Google. It answers "are you really this person?" and is the gate every account-based app needs before anything else.Learn more
- Row-level security (RLS)
- Database rules that decide which rows each user can read or write, enforced by the database itself rather than your app code. With Supabase it's the safety net that stops one user from querying another's data even if a frontend check is missing.Learn more
- Webhook
- A way for one service to notify yours the moment something happens — Stripe telling your app a payment succeeded — by POSTing to a URL you expose. You react in real time instead of polling for changes.Learn more
- Idempotency
- Designing an operation so running it twice has the same effect as running it once. It's what keeps a retried webhook or a double-clicked button from charging a customer or creating an order twice.Learn more
- Rate limiting
- Capping how many requests a user or client can make in a window, returning a "too many requests" response past the limit. It protects your app and your API bills from abuse, runaway loops, and accidental floods.Learn more
- CORS
- Browser rules that control which websites may call your API from frontend code. When a fetch works in your terminal but fails in the browser with a CORS error, the server needs to allow your site's origin.
- Serverless functions
- Backend code that runs on demand without you managing a server — it spins up per request and scales automatically. Hosts like Vercel run your API routes this way, which is why a vibe-coded app can handle traffic with no ops work.Learn more
- Server vs. static rendering (SSR/SSG)
- Two ways a page reaches the user: rendered fresh on each request (SSR) or built once ahead of time and served as static files (SSG). Static is faster and cheaper for content that rarely changes; server rendering suits pages that depend on the current user.
- CI/CD
- Automation that checks your code on every change (continuous integration) and ships it when checks pass (continuous deployment). For vibe coders it means tests and the build run themselves, so broken code is caught before it reaches users.Learn more
- Product-market fit (PMF)
- The point where a product clearly solves a real problem for a group of people who keep using it and tell others. Vibe coding makes building cheap, so the hard part shifts to finding fit — ship small, watch what sticks.Learn more
- Recurring revenue (MRR / ARR)
- Predictable income from subscriptions, measured monthly (MRR) or annually (ARR). It's the metric most indie SaaS builders track, because steady recurring revenue beats one-off sales for funding ongoing work.
- Conversion rate
- The share of visitors who take the action you want — sign up, buy, join the waitlist. Small wording and layout changes move it, which is why landing pages get tested rather than guessed at.
- Paywall
- The point where a user must pay to unlock a feature or keep using the product. Where you place it — and how much you give away first — is one of the biggest levers on revenue for a small product.