MUXAI Wiki

AI Glossary

Agentic and development terms, explained for designers.

Short definitions for terms you hit when working with agents, repos, and design systems — without the engineer rabbit hole.

Filter glossary

A

Accessibility: Design and code practices that make interfaces usable by people with disabilities — keyboard navigation, screen reader labels, color contrast, focus states, and semantic HTML. Agents can implement a11y patterns, but you still need to review with real assistive tech and WCAG targets your org sets.
Agent: An autonomous or semi-autonomous program that can take goals, use tools, and produce outputs (code, copy, designs) with minimal step-by-step hand-holding. In Cursor, the agent runs in your repo with rules and skills as guardrails.
AI slop: Generic, template-like UI that LLMs default to — purple-gradient heroes, centered everything, Inter-only typography, identical nav bars, icon-tile feature grids. Looks fine at a glance but reads as AI-generated. Skills like design-review, hallmark, and frontend-design push agents away from slop toward distinctive, on-brand craft.
API: Application Programming Interface — a structured way for software to request data or actions from another service. "Call the API" means fetch user info, post a form, or pull Figma assets programmatically. Agents often integrate APIs when a design needs live data.
API key: A secret string that proves your app is allowed to use a service (OpenAI, Figma, Stripe, etc.). Never commit keys to Git or paste them in chat. Store them in environment variables or a local `.env` file that stays out of the repo.
Authentication: How an app knows who you are — login, sessions, tokens, OAuth. Lives on the server and backend, not in visible UI alone. Agents mention auth when a feature needs sign-in, protected routes, or per-user data. Designers usually shape the flows; agents wire the plumbing.

B

Backend: The server-side logic users don't see — saving data, handling logins, sending emails, talking to APIs. Designers rarely touch backend directly, but agents may mention it when a feature needs a database or auth. "Frontend only" is a valid scope for prototypes.
Branch: A parallel line of work in Git — try a redesign on `feature/new-nav` without touching `main`. Branches keep experiments safe until you're ready to merge. Agents often create branches automatically for larger tasks.
Build: The step that compiles and optimizes your project into files ready for production — minified CSS, bundled JavaScript, static pages. `npm run build` must succeed before deploy. If build fails, the agent needs to fix errors before shipping.

C

Cloud: Running apps and storing files on remote servers (AWS, Vercel, Netlify, etc.) instead of only on your laptop. "Deploy to the cloud" means publish a live URL others can open. Agents can help configure deploys; you often connect GitHub so every push can update the site.
Commit: A saved snapshot of changes in Git with a message describing what changed. Commits are local until you push. Agents create commits when you ask; read the message and diff so you know exactly what landed in history.
Component: A reusable UI building block — a Button, Card, or NavBar used across many screens. Design systems in Figma map cleanly to components in code. Agents compose pages by assembling components instead of redrawing the same element everywhere.
Context: Everything the model can "see" in a session — open files, rules, skills, chat history, and tool results. More relevant context usually means better output, but context has limits (token window). Point the agent at the right files instead of pasting entire repos.
Context artifacts: Durable files and references the agent reads every run — PRODUCT.md, design.md, guidelines, Figma links, briefs, token docs. Stage 2 of the MUXAI workflow. Unlike chat history, artifacts persist in the repo so you do not re-explain decisions each session.
CSS: Cascading Style Sheets — rules that control how HTML looks: colors, spacing, fonts, layout, hover states, and responsive breakpoints. Design tokens often map to CSS variables. When you say "match the Figma spacing," the agent is mostly writing CSS.
Cursor: The AI-native IDE where designers and engineers run agents in a repo. Cursor reads project rules (`.cursor/rules`, `AGENTS.md`), skills, and open files as context — the main harness surface for MUXAI workflow work.

D

Database: Organized storage for app data — users, orders, content, settings. Designers usually don't design databases, but features like "save my preferences" or "show a list of projects" need one. Agents may suggest a database when a prototype outgrows hard-coded sample data.
Deployment: Publishing a built version of your app so it's live on the web. Deployments often trigger automatically when you push to `main`. Preview deploys give you a temporary URL to share a work-in-progress without affecting production.
Design drift: When coded UI slowly diverges from your design system — new colors per screen, one-off components, mixed spacing, skipped states. Each change is small; together the work stops feeling intentional. The design-review skill audits drift across 11 dimensions and realigns output to your established tokens and components.
Design system: Shared library of components, tokens, typography, and patterns your product reuses — often in Figma and in code (e.g. shadcn/ui). Agents stay on-brand when `design.md`, tokens, and component docs are in the repo; without them, output drifts toward generic AI UI.
Diff: A line-by-line comparison showing what changed in a file — additions in green, deletions in red. Git diffs and pull request views help you review agent output before merging. Always skim the diff when the agent touches layout or tokens.
Domain: The web address people type to reach your site — like `yourproject.com`. Custom domains get connected after deploy. "Local" development uses `localhost` instead; the domain is the public face of a shipped product.

E

Environment variable: Config or secrets stored outside your code — API keys, database URLs, feature flags. Usually defined in a `.env` file locally and in your host's dashboard for production. Agents should reference env vars by name, never hard-code secrets in source files.

F

Figma: Collaborative design tool for UI — frames, components, variables, and prototypes. In MUXAI workflow, Figma files or exports become context artifacts; some skills scaffold code from Figma Make exports or sync tokens back into design.
Framework: A structured toolkit for building apps — React, Vue, Astro, Next.js, etc. Frameworks provide routing, components, and build pipelines so you don't start from zero. Tell the agent which framework the project uses so output matches existing patterns.
Frontend: Everything users see and interact with in a browser or app — layouts, buttons, typography, animations. When you ask an agent to "build this screen," you're usually asking for frontend work. HTML, CSS, and JavaScript (or frameworks like React) power the frontend.

G

Git: Version control software that records every change to your project over time. Git lives on your machine; GitHub (or GitLab) is where repos are often stored online. Agents use Git commands to commit, branch, and sync work — you review the diff before merging.
GitHub: A popular website for hosting Git repos, reviewing changes, and collaborating. Designers use it to back up work, share prototypes, and open pull requests for feedback. Many agents and deploy tools connect directly to GitHub.

H

Harness: The full environment you give an agent to work in — IDE settings, rules, skills, design system, and repo conventions. A good harness reduces rework and keeps output on-brand.
HTML: HyperText Markup Language — the structural skeleton of web pages. Tags like `<button>`, `<nav>`, and `<img>` define what exists on a page, not how it looks. Agents generate HTML when turning designs into pages; CSS and JavaScript layer on top.

J

JavaScript: The programming language that makes web pages interactive — clicks, form validation, animations, fetching data. Often abbreviated JS. Agents use JavaScript (or TypeScript) to wire up components, handle state, and connect UI to APIs.
JSON: A plain-text data format APIs and config files use — key/value pairs in curly braces. Agent output and network responses often show JSON in the terminal or editor. You read it to verify structure; you do not need to author it manually.

L

Library: Pre-written code you install instead of building from scratch — icon sets, date pickers, animation helpers, UI kits. Libraries ship through npm as packages. When an agent says "add a library," it means pulling in battle-tested code and wiring it to your design system.
LLM: Large Language Model — the AI that reads your prompts and writes code, copy, or explanations. ChatGPT, Claude, and Cursor's agent all run on LLMs. You don't pick the model directly in most design workflows; you steer it with clear prompts and context.
Localhost: Your own computer acting as a temporary web server during development — typically `http://localhost:5173` (Vite/React) or another port your dev script prints. Localhost lets you preview changes instantly before deploying. Only you can see it unless you use a tunnel or preview deploy.

M

Markdown (.md): A plain-text format for writing docs with simple syntax — headings, lists, links. Files ending in `.md` are Markdown. README, skills, rules, and wiki pages often use it because both humans and agents read it easily.
MCP: Model Context Protocol — a standard way for AI tools to connect to external services (Figma, GitHub, databases). MCP servers expose tools the agent can call during a task.
Merge: Combine changes from one Git branch into another — usually a feature branch into `main`. Merging is how approved work lands in the shared codebase. Agents can merge, but for important releases you may want to review the pull request first.
Model: A trained AI system that understands and generates text (and sometimes images or code). "Which model?" usually means speed vs. quality — faster models for quick edits, stronger models for complex refactors. In agent work, the model is the brain; rules, skills, and your repo are the memory.

N

Node.js: A runtime that lets JavaScript run outside the browser — on your machine or a server. Many dev tools (including Astro, Vite, and npm scripts) depend on Node.js. You'll install it once during setup; agents assume it's available when running build commands.
npm: Node Package Manager — the default way to install libraries, run project scripts, and manage dependencies. Commands like `npm install` and `npm run dev` show up constantly in agent terminals. Listed versions live in `package.json` and `package-lock.json`.

P

Package: A reusable code library installed into your project — UI kits, icons, date pickers, etc. Packages come from npm and are listed in `package.json`. Agents add packages when a feature needs them; approve installs so you know what's entering the repo.
Prompt: The instructions you give an agent — what to build, what to avoid, which file or frame to reference. Good prompts are specific: "Implement this Figma frame using our Button component and 8px spacing" beats "make it look nice."
Pull: Download the latest changes from a remote repo into your local copy. `git pull` keeps your machine in sync when others (or another agent session) updated the project. Pull before starting work to avoid merge conflicts.
Pull request: A proposal to merge your branch into the main codebase, usually on GitHub. PRs show a visual diff, comments, and checks. Designers use PRs to request review before shipping — even when an agent wrote the code.
Push: Upload your local Git commits to a remote host like GitHub. After you push, teammates (or deploy services) can see the latest changes. Agents may push for you — confirm you're on the right branch and that secrets aren't included.

R

React: The dominant UI framework for building interfaces from composable pieces. Pages are trees of components with state and props — close to how you think in Figma variants and instances. MUXAI setup scaffolds React; agents assume component-based patterns when extending screens.
Repo: Short for repository — a project folder tracked by Git, usually containing code, assets, config, and docs. "Open the repo in Cursor" means give the agent the full project context. One repo often equals one app or design system package.
Route: A URL path mapped to a page or view — `/`, `/about`, `/settings`. Routing defines site navigation structure. When you add a new screen in Figma, the agent creates a matching route so the URL works in the built app.

S

Scripts: Short commands defined in `package.json` that run common tasks — start the dev server, build for production, run tests. `npm run dev` is a script. Tell the agent "run the dev script" instead of memorizing long terminal commands.
Server vs client: Where code runs: client is the browser (what users see and click); server is the cloud machine handling data, auth, and secrets. Same language (JavaScript) can run in both, but capabilities differ — only the client manipulates the DOM; only the server safely holds API keys.
Skill: A packaged instruction set (often a SKILL.md in a repo) that teaches an agent how to perform a specialized task — e.g. shadcn setup, design review, or deployment.
Source code: The human-readable files that make up a project — components, styles, config, docs. Your Figma file is the design source; the repo is the code source. Agents edit source files; Git tracks every change so you can review, revert, or share work safely.

T

Terminal: A text interface for running commands on your computer — install packages, start servers, run Git. Cursor embeds a terminal; agents can execute commands there with your approval. You don't need to memorize commands if you describe the goal in plain language.
Token: In design systems, a named value (color, spacing, font size) used consistently across UI. In LLMs, a unit of text the model reads or generates; context limits are often measured in tokens.
Types: In TypeScript, types describe the shape of data — e.g. a Button must have a `label` string and an optional `disabled` flag. Types catch mistakes before runtime. You don't need to write them yourself; agents add types to keep props and API responses consistent.
TypeScript: JavaScript with type rules layered on top — the agent catches shape mismatches (wrong props, missing fields) before the app runs. Most modern React projects use `.ts` and `.tsx` files instead of plain `.js`. You review types in diffs; you rarely write them by hand.

V

Variables: Named placeholders for values that can change. In CSS, variables store colors and spacing (often as `--token-name`). In code, variables hold data like user names or counts. Environment variables hold secrets and config outside the codebase.
Vibe coding: Building software by describing what you want in natural language and letting an agent generate code — fast and exploratory, but often without formal structure, tests, or production practices. MUXAI workflow and vibe-to-prod skill help move from vibe coding toward repeatable, reviewable, ship-ready work.