Vibers Codex
A shared language for AI-native builders
What This Is
A vibe coder is someone who builds software by expressing intent to AI systems rather than writing every line by hand. It's not about being lazy or taking shortcuts—it's about leverage. The same way a developer in 2010 wouldn't hand-write assembly, a developer today doesn't need to hand-write every function.
Language matters because it shapes thinking. When a team shares vocabulary, they communicate faster and make fewer mistakes. This codex exists to make the implicit explicit—to give names to patterns that experienced AI-native builders already use, so newcomers can learn faster.
Modern AI-native development requires new mental models. The old abstractions (files, functions, classes) still matter, but they're joined by new ones: agents, context windows, prompt engineering, human-in-the-loop workflows. Understanding these concepts is table stakes for building effectively with AI.
"Vibe coding isn't about shortcuts. It's about leverage."
Core Vibe Coder Principles
These aren't rules. They're mental models that help you make better decisions faster.
Ship > Theorize
Working software teaches you more than speculation ever will. Get it in front of users.
Intent Over Ceremony
Express what you want clearly. Let tools handle the boilerplate and ceremony.
Systems Over One-Offs
Build pipelines and processes that can run repeatedly, not artisanal one-time efforts.
Leverage Over Labor
Multiply your output by using the right tools. Manual effort is a last resort.
Humans Own Judgment
Machines execute. Humans decide what matters, what ships, and what gets killed.
Distribution = Correctness
Great code nobody sees is worthless. Shipping includes getting it to users.
Readability Beats Cleverness
Code is read more than written. Optimize for the next person (including future you).
Determinism Beats Magic
Predictable systems you can debug beat magical systems you can't understand.
The Vibe Coder Glossary
Terms you'll encounter in AI-native development, defined for builders.
AI-Native Building Terms
- Vibe Coding
- Building software by describing intent to AI systems rather than writing every line manually. The focus shifts from syntax to outcomes.
- Agent
- An AI system that can take actions autonomously within defined boundaries—reading files, running commands, making decisions.
- Agentic Loop
- The cycle where an agent observes its environment, decides on an action, executes it, and repeats until the goal is achieved or it gets stuck.
- Human-in-the-Loop
- System design that requires human approval at critical decision points. The AI proposes, the human disposes.
- Self-Prompting
- When an agent generates its own follow-up prompts to continue work, rather than waiting for human input at every step.
- Planner / Executor / Critic
- A common agent architecture: one component plans the approach, another executes it, a third evaluates the result.
- Adversarial Review
- Using a second AI to critique the output of the first. Catches errors, inconsistencies, and blind spots.
- Bounded Autonomy
- Giving an agent freedom to act within explicit constraints. It can choose how, but not what or whether.
- Tool Calling
- The capability for an AI to invoke external functions—file operations, API calls, shell commands—rather than just generating text.
- Context Window
- The amount of text an AI can process at once. Everything outside this window is effectively forgotten.
- Model Drift
- When an AI's behavior changes over time due to updates, leading to different outputs for the same inputs.
- Model-as-Collaborator
- Treating the AI as a junior team member rather than a magic oracle. It has strengths, weaknesses, and needs direction.
- Reasoning vs Execution
- Separating the thinking phase (what should we do?) from the doing phase (actually doing it). Different prompts for different jobs.
Pipeline & Systems Thinking
- Pipeline
- A sequence of automated stages that transform inputs into outputs. Each stage has clear inputs, outputs, and responsibilities.
- Stage
- A discrete step in a pipeline with defined inputs and outputs. Stages can be run independently for debugging.
- Deterministic Run
- An execution where the same inputs always produce the same outputs. Essential for debugging and reproducibility.
- Run Folder
- A timestamped directory containing all artifacts from a single pipeline execution. Everything in one place.
- Quality Gate
- A checkpoint that validates output before proceeding. Fails fast when something is wrong.
- Orchestration
- The coordination layer that decides which stages run, in what order, and handles failures gracefully.
- Control Plane
- The system that manages and monitors execution—distinct from the execution plane that does the actual work.
- Execution Plane
- Where the actual work happens. Receives instructions from the control plane, returns results.
- Reproducibility
- The ability to re-run a process and get the same result. Requires capturing all inputs and configuration.
- Auditability
- The ability to trace back through execution history to understand what happened and why.
- Failure Surfaces
- The points where a system can fail. Good design minimizes these and makes failures obvious when they occur.
IDE & Workspace Terms
- IDE
- Integrated Development Environment. The application where you write, edit, and debug code.
- AI-Native IDE
- An IDE built around AI assistance as a core feature, not an afterthought. Cursor, Windsurf, and similar tools.
- Workspace
- The collection of files, folders, and configuration that make up your current project context.
- Repo
- Repository. A version-controlled directory containing a project's source code and history.
- Monorepo
- A single repository containing multiple related projects. Shared dependencies, coordinated releases.
- Diff
- The difference between two versions of a file. Shows what changed, line by line.
- Patch
- A file containing diffs that can be applied to transform one version into another.
- Build Artifact
- The output of a build process—compiled code, bundled assets, documentation. The thing you ship.
- Preview Environment
- A temporary deployment for testing changes before they hit production. See it live without risk.
- Local vs Managed Execution
- Running builds on your machine versus in cloud infrastructure. Trade-offs between control and convenience.
Product & Startup Language
- SaaS
- Software as a Service. Hosted software accessed via subscription rather than one-time purchase.
- B2C / B2B
- Business-to-Consumer vs Business-to-Business. Who you're selling to changes everything about how you build and sell.
- Distribution
- How your product reaches users. The channel, not just the product. Often harder than building.
- PMF (Product-Market Fit)
- When you've built something people actually want and will pay for. The inflection point where growth becomes possible.
- Onboarding
- The experience of a new user learning your product. First impressions that determine retention.
- Conversion
- When a user takes a desired action—signing up, paying, upgrading. The moments that matter.
- Paywall
- The boundary between free and paid features. Where and how you draw this line defines your business.
- Entitlements
- What features a user has access to based on their plan or status. The access control layer.
- Feature Gating
- Conditionally showing features based on user status, plan, or flags. Not everyone sees everything.
- UX Debt
- Accumulated friction in your user experience. Quick fixes that become long-term drag on usability.
- Shipping Surface
- The interface through which users experience your product. App Store, web, CLI—where you meet users.
- Internal Tools vs Products
- Tools you build for yourself versus tools you sell. Different quality bars, different concerns.
Vibe Coder Culture Terms
- Ship-First
- Prioritizing getting something live over getting it perfect. You can iterate on live software; you can't iterate on nothing.
- Build in Public
- Sharing your work, progress, and learnings openly as you build. Accountability and community through transparency.
- Founder Mode
- The mindset of treating every problem as your problem. Ownership without waiting for permission.
- Operator Mindset
- Thinking about systems, leverage, and outcomes rather than just completing tasks. Strategy over tactics.
- Prompt-as-Code
- Treating prompts with the same rigor as code—version controlled, tested, documented, reviewed.
- Spec Prompt
- A detailed prompt that serves as a specification for what should be built. The input that defines the output.
- One-Shot Prompt
- A prompt designed to get a complete, usable result in a single generation. No back-and-forth required.
- Prompt Drift
- When prompts that used to work start producing different results. Usually due to model updates.
- Overfitting to the Model
- Building workflows so dependent on one AI's quirks that they break with any model change.
- Glue Code
- The code that connects components together. Often undervalued, frequently where bugs hide.
- Infra Thinking
- Considering how code will run, scale, and fail—not just whether it works locally.
- "Make it Legible"
- Ensuring others (and future you) can understand what was built and why. Documentation as a first-class concern.
- "Own the Clock"
- Taking control of your schedule and focus. Protecting deep work time from interruption.
How This Shows Up in App Factory
App Factory isn't just software that happens to use AI. It's built around the principles in this codex.
Stages exist for a reason
Each pipeline stage has clear inputs and outputs. When something goes wrong, you know exactly where. No magical black box that either works or doesn't.
Runs are deterministic
Same input, same output. Run folders capture everything. You can debug, reproduce, and audit any build.
Humans stay in control
App Factory proposes, you decide. Review outputs, adjust direction, override when needed. The AI is a tool, not the boss.
Artifacts are visible
Every build produces artifacts you can read, edit, and learn from. Market research, specs, code—all in plain files, not hidden in a database.
Who This Is For
For
- Builders shipping real things
- People who care about leverage
- Teams using AI seriously as a tool
- Those who value systems over heroics
Not For
- Prompt collectors who never ship
- "AI hype" chasers looking for magic
- People expecting buttons to do everything
- Those allergic to reading docs