Every lesson, guide, and resource is yours to explore without an account. But if you sign in, your progress is tracked across sessions and devices — pick up where you left off and build your learning record.
Sign in to track your progress and pick up where you left off.
Glossary
Key terms and definitions from the Open Vector curriculum.
A software system that uses a large language model to autonomously perform tasks, make decisions, and interact with tools on behalf of a human operator. Agents go beyond simple chat — they read files, write code, run commands, and iterate toward a goal.Related lesson →
API
Application Programming Interface. A defined contract that lets two systems talk to each other — one sends a request, the other sends a response. APIs are how your frontend gets data from your backend, and how services communicate across the internet.Related lesson →
B
Boundaryless
The Zero Vector principle that traditional role boundaries between design and engineering are artificial constraints. A Systems Auteur works across the full stack — research, design, architecture, code, deployment — because the medium demands fluency, not fragmentation.Related lesson →
Branch
A parallel line of development in Git. Branches let you work on features or experiments without affecting the main codebase. When the work is ready, you merge it back. Think of it as a safe sandbox for changes.Related lesson →
Build Step
The process that transforms your source code into production-ready files. For a React app, this typically means bundling JavaScript, optimizing assets, and outputting static files a server can host. If the build fails, nothing deploys.Related lesson →
C
CLAUDE.md
A markdown file placed at the root of a repository that gives Claude Code project-specific instructions, context, and rules. It is the primary mechanism for shaping agent behavior per-codebase — personality, workflow constraints, architecture notes, and domain knowledge all live here.Related lesson →
CLI
Command Line Interface. A text-based way to interact with your computer by typing commands instead of clicking buttons. The terminal runs a CLI shell. Mastering the CLI is foundational — it is how developers and agents operate.Related lesson →
Commit
A snapshot of your project at a specific point in time, saved in Git. Each commit has a message describing what changed and why. Commits are the atoms of version history — small, intentional, and reversible.Related lesson →
Component
A self-contained, reusable piece of UI in React. Components accept data (props), manage their own state, and return markup. Good components are small, focused, and composable — like LEGO bricks for interfaces.Related lesson →
Context Window
The total amount of text (measured in tokens) that a language model can process in a single interaction. Everything the model reads and generates must fit within this window. Managing context is a core skill — what you include shapes what the model can do.Related lesson →
CRUD
Create, Read, Update, Delete — the four fundamental operations for persistent data. Nearly every application is, at its core, a CRUD system with a specific user experience layered on top. Understanding CRUD clarifies what your system actually does.Related lesson →
CSS
Cascading Style Sheets. The language that controls how HTML elements look — layout, color, typography, spacing, animation. CSS is where design intent meets the browser. Writing good CSS means understanding the cascade, specificity, and the box model.Related lesson →
D
Data Modeling
The practice of defining what your system knows — its nouns, their attributes, and the relationships between them. A data model is the skeleton of your application. Get it right and everything else flows; get it wrong and you fight the structure forever.Related lesson →
Deployment
The process of making your application available on the internet. This typically involves pushing code to a hosting platform that runs a build step and serves the output. Deployment is where your work becomes real — from localhost to the world.Related lesson →
Design-Led Engineering
An approach where design thinking drives technical decisions, not the other way around. The designer does not hand off mockups to be interpreted — they work in the medium, shaping code with the same intentionality they bring to wireframes. Engineering serves the design vision.Related lesson →
DNS
Domain Name System. The internet's phone book — it translates human-readable domain names (like zerovector.design) into IP addresses that servers understand. Configuring DNS is the bridge between buying a domain and your site actually appearing at that address.Related lesson →
E
Environment Variables
Key-value pairs stored outside your codebase that configure how your application behaves. API keys, database URLs, and feature flags are common examples. They keep secrets out of your code and let the same codebase run differently in development vs. production.Related lesson →
F
Feedback Loop
A cycle where the output of a system feeds back as input, reinforcing or correcting behavior. In design, fast feedback loops (deploy, observe, adjust) produce better outcomes than long planning cycles. Tighten your loops — ship, learn, iterate.Related lesson →
G
Git
A distributed version control system that tracks changes to files over time. Git lets you save snapshots (commits), work in parallel (branches), and collaborate without overwriting each other's work. It is the foundation of modern software development.Related lesson →
I
Information Architecture
The structural design of shared information environments. IA defines how content is organized, labeled, and connected so that people can find what they need and understand where they are. It is the blueprint that precedes any visual design.Related lesson →
Investiture
In Brandon Sanderson's Cosmere, Investiture is the fundamental energy that powers magic systems. In Zero Vector, it is a metaphor for design mastery — the deep, practiced knowledge that lets a designer channel powerful tools (like AI) with precision and intent, rather than flailing with raw power.Related lesson →
J
Jobs to Be Done (JTBD)
A framework for understanding what users actually hire a product to do. Instead of asking "what features do they want," you ask "what progress are they trying to make?" JTBD shifts focus from demographics to motivation — the why behind the action.Related lesson →
L
localhost
Your own computer acting as a web server. When you run a development server, it serves your application at localhost (usually http://localhost:3000 or similar). It is your private preview — only you can see it until you deploy.Related lesson →
M
Multi-Agent System
An architecture where multiple AI agents collaborate on a shared goal, each with a defined role and domain. Instead of one agent doing everything, specialized agents handle backend, frontend, marketing, and operations — coordinated through shared context and clear contracts.Related lesson →
N
Nouns and Verbs
A systems thinking shorthand: nouns are the things in your system (users, posts, projects), and verbs are what can be done to them (create, edit, archive). Defining nouns and verbs early forces clarity about what your application actually is.Related lesson →
O
Orchestration
The practice of coordinating multiple agents, tools, or processes toward a unified outcome. Orchestration defines who does what, in what order, with what inputs. It is the difference between a group of agents and a functioning team.Related lesson →
P
Prompt Engineering
The craft of writing instructions that reliably produce desired behavior from a language model. Good prompts are specific, structured, and context-rich. Great prompts encode intent so clearly that the model feels like a collaborator, not a slot machine.Related lesson →
Q
Quality Gates
Defined checkpoints in a workflow where output must meet specific criteria before proceeding. In an agentic pipeline, quality gates prevent compounding errors — each agent's work is validated before the next agent builds on it. Ship with confidence, not hope.Related lesson →
R
RAG (Retrieval-Augmented Generation)
A pattern where a language model is given relevant documents retrieved from a knowledge base before generating a response. Instead of relying on training data alone, the model answers grounded in your specific content. RAG is how you make AI an expert on your domain.Related lesson →
React
A JavaScript library for building user interfaces through composable components. React uses a declarative model — you describe what the UI should look like for a given state, and React figures out how to update the DOM efficiently. It is the dominant paradigm for modern web frontends.Related lesson →
Repository
A Git-tracked project directory containing your code, history, and configuration. A repo is the canonical home for a codebase. It holds every commit ever made, every branch, and (when pushed to GitHub) becomes the collaboration hub for a team.Related lesson →
S
Semantic HTML
HTML that uses elements according to their meaning, not just their appearance. A <nav> is navigation, an <article> is content, a <button> triggers an action. Semantic HTML improves accessibility, SEO, and code clarity — it tells the browser (and the developer) what things are.Related lesson →
SPA (Single Page Application)
A web application that loads once and dynamically updates content without full page reloads. Navigation happens client-side — the browser swaps components in and out while the URL updates. SPAs feel fast and app-like but require careful handling of routing, SEO, and initial load.Related lesson →
Systems Auteur
The Zero Vector ideal: a practitioner with deep design fluency who wields AI agents to operate across the entire product lifecycle — research, architecture, code, deployment, and marketing. Not a generalist who does everything poorly, but a design mind with system-wide reach through agentic amplification.Related lesson →
Systems Thinking
The practice of understanding how parts of a system interrelate and influence each other over time. Instead of solving problems in isolation, systems thinking reveals feedback loops, dependencies, and emergent behavior. It is the foundation of good architecture and good design.Related lesson →
T
Terminal
The application that provides access to your computer's command line interface. Through the terminal, you run shell commands, navigate the file system, execute scripts, manage Git, and operate AI agents like Claude Code. It is the cockpit.Related lesson →
The Crew Model
A multi-agent organizational pattern where each AI agent has a defined persona, domain, and responsibilities — like a film crew. Instead of one monolithic assistant, you run a team: an architect, a frontend specialist, a backend engineer, a marketer, each with their own CLAUDE.md and voice.Related lesson →
V
Vibe Coding
The practice of generating code through AI prompts without understanding what the code does, how it works, or why it is structured that way. Vibe coding produces output without comprehension. It is the opposite of working in the medium — it is letting the tool work you.Related lesson →
W
Work in the Medium
The Zero Vector principle that designers must engage directly with the material of their craft — code, not just mockups. Working in the medium means understanding the constraints, affordances, and grain of the technology you are designing for. You cannot design what you do not touch.Related lesson →
Z
Zero-Vector Design
A design philosophy and manifesto arguing that AI is the most powerful design tool ever created — if wielded with intention, craft, and systems thinking. Zero Vector rejects vibe coding and reclaims agency: designers should lead the engineering, not be replaced by it. The name invokes a vector with magnitude but no predefined direction — pure potential, awaiting intent.Related lesson →