Frankenstack — unified cockpit for chaotic stacks Frankenstack

Project Hub

📖 Vibe-Coding Glossary

Share this glossary

You don't need a CS degree to ship. But some words come up in every AI chat, and knowing them makes the agent's answers dramatically better. Here's the vocabulary, in plain words, with the tiniest useful examples.

Your first prompt — start here

Copy this into your regular chatbot (ChatGPT, Claude, Gemini) — not into the coding agent (VS Code, Codex, Antigravity). The chatbot plans and teaches; the coding agent builds. Beginners lose weeks by pasting vague goals straight into the agent and letting it free-run.

I'm a complete beginner — I want to build a web app that helps me track my daily calorie intake (food log, daily totals, a simple weekly chart). Before writing any code, please: 1. Explain what building blocks I'll need: where the app will run (hosting), where the data lives (database), how people sign in (auth), how emails get sent, and how people could pay. 2. Recommend a modern, fast, secure tech stack for a solo beginner in 2026 — and explain WHY in plain words, not buzzwords. 3. Write me a step-by-step plan I can hand to a coding agent, one step at a time. Keep each step small enough to finish in one chat message, and end every step with a check I can run to verify it worked before moving on. 4. List the 5 mistakes beginners usually make at this point, so I can avoid them. Do NOT write the actual code yet — first teach me the plan and the vocabulary I'm missing. Ask me clarifying questions if my goal is too vague.
⬇ Download as .md

Start here: the file that talks to your agent

When you start a project, AI agents (Claude Code, Cursor, Copilot) look for an instruction file in the repo root. It's usually called AGENTS.md or agent.md — a plain text file where you describe the project: what it is, what stack it uses, what rules the agent must follow ("always run tests before committing", "never edit the schema without asking"). Think of it as the sticky note on the fridge for your robot coworker. Write it on day one, keep it short, update it when the rules change — it's the cheapest way to stop repeating yourself in every chat.

GitHub — where code lives

A repo (repository) is a folder with your project plus its full history. A commit is a saved snapshot ("changed the pricing text"), a push uploads snapshots to GitHub, and a Pull Request proposes changes before they land. Even solo, use it: the history means you can always go back to yesterday's working version. Vibe-coding rule of thumb: commit after every feature that works — small, boring commits are the cheapest insurance in software.

Database — where data lives

Code forgets everything when it restarts. A database remembers. The common type is a relational database — think of a supercharged spreadsheet: tables (sheets), rows (entries), columns (fields). You ask it questions with SQL:

SELECT email, plan FROM users WHERE plan = 'free';

That reads: "give me the email and plan of every user whose plan is 'free'". An ORM (like Prisma) lets your code do the same thing without writing SQL. Two flavors you'll meet: SQLite — the whole database is one file, perfect for small projects — and Postgres — the industry standard, hosted for you by services like Supabase or Neon. If you don't know which to pick: Postgres via Supabase, and don't look back.

Cron job — the alarm clock

A cron job is code that runs on a schedule without you. "Every day at 9:00, email my users their summary." "Every 5 minutes, ping my API and check it's alive." The schedule is written in a cryptic 5-field string you never need to memorize:

0 9 * * * → every day at 09:00 */5 * * * * → every 5 minutes 0 0 * * 1 → every Monday at midnight

You'll meet crons as GitHub Actions (free for public repos), platform features (Vercel Cron, Cloudflare Cron Triggers), or hosted services (cron-job.org). The classic beginner trap: a cron that silently dies — you find out weeks later. That's exactly what heartbeat monitoring (and Frankenstack) exists for.

Domain — your address on the internet

A domain (frankenstack.app) is a name you rent from a registrar (Namecheap, Cloudflare, Porkbun — yearly, usually $10-15). DNS is the phonebook that turns the name into a server address: an A record points to an IP, a CNAME points to another name (this is how "myapp.vercel.app" becomes "myapp.com"). A subdomain is a free child you can point anywhere (blog.myapp.com). Rule of thumb: buy the domain the day you pick the name — cheap insurance against the name being taken.

The platforms, grouped by what they do

Hosting — where the website runs: Vercel (next.js, easiest start), Cloudflare Workers/Pages (fast, generous free tier), Netlify. You push code, they run it — you never touch a server.
Backend as a Service — pre-built backend parts: Supabase (Postgres database + login + file storage — the default choice for vibe-coded apps), Firebase (Google's older, more closed version), Convex (modern reactive database, great with realtime), Neon (Postgres only, generous free tier), Turso (SQLite, edge-friendly).
Server hosting — for code that must run all the time: Railway and Render run long-lived processes (APIs, bots, workers) that serverless platforms handle less naturally. Fly.io too, with more knobs.
Email — sending mail without landing in spam: Resend (dev-favorite, clean API), Loops (marketing emails/newsletters), SendGrid (the veteran). All have free tiers; your transactional emails (password resets) should go through one of these, never through a personal Gmail.
Payments: Lemon Squeezy and Paddle act as "merchant of record" — they handle VAT/tax paperwork for you, which matters a lot for solo builders. Stripe is the most powerful but taxes are your problem.

AGENTS.md — the ready-made template

What it is: a copy-paste instruction file you drop into your repo root as AGENTS.md. Coding agents (Claude Code, Cursor, Copilot, Codex) read it automatically at session start — it is how you tell your robot coworker the rules once, instead of repeating them in every chat.

What's inside: a fill-in Project section (name, stack, commands), standing rules (commit every session, verify deploys in production, never change the schema silently), a free-first tool policy, a structure for growing projects — the 3-layer architecture (Markdown SOPs in directives/, the agent as the routing layer, deterministic tools in execution/), a self-annealing loop (every bug updates the directive, so the system gets stronger) — and three pre-configured agent tools:

  • vexp — context-aware code navigation: one run_pipeline call returns the files you need instead of opening them one by one. Runs entirely on your machine — free, no key.
  • Rafter — a security review gate: when your change touches auth, payments, input handling, SQL or files, the agent must run a security review before calling it done. Local secrets scan is free and offline; the deep scan asks for an API key once, and falls back to a manual review checklist if you don't have one.
  • Ponytail — "lazy senior dev" mode: a ladder that prefers reuse, stdlib and one-liners over new dependencies and speculative abstractions — while never simplifying away validation, security or accessibility.
  • 3-layer architecture — for when the project outgrows a single chat: SOPs in Markdown (directives/), the agent routes between them, deterministic scripts do the work (execution/). Includes a self-anneal loop and a strict file layout (.tmp/ never committed, secrets in .gitignore).

How the free-first rule works: the agent runs everything on the free tier by default. The first time a paid feature comes up, it asks you once ("Do you have an API key for this?"). If yes, it switches on the deeper mode and never asks again this session; if no, it does the free fallback, tells you clearly, and keeps going. Keys are read from environment variables only — never hardcoded, never echoed, never committed.

⬇ Download AGENTS.md template

This glossary is growing. Next up: snippets we actually use (cron configs, Supabase keepalive, webhook handlers) and ready-made solutions from our own projects — linked right from here, so a beginner can copy working code instead of assembling it from forum posts. Want a term explained? open an issue.