Glossary

Short definitions for every term used in the workshop.

Agentic coding: A style of software development where an AI agent plans, edits, runs, and verifies code in a loop, with the human reviewing and steering rather than typing every line. The agent uses tools (file edits, shell, tests) and decides when each is needed. Contrasts with vibe coding, where the human prompts and the AI replies one shot at a time.
Agentic loop: The four-step cycle every agentic system runs: Decide → Act → Observe → Revise. The agent picks the next move (Decide), takes it (Act — an edit, a shell command), reads what came back (Observe — the output or error), and adjusts (Revise). Most agent failure modes — confidence on a wrong path, repeated misreads — are problems at one specific step.
Antigravity: Google's AI IDE for agentic development. Built around an autonomous coding agent that can plan, edit files, run commands, and use MCP tools. Used as the primary editor in this workshop.
API (Application Programming Interface): A defined way for software to talk to other software. In this workshop you "enable" specific Google Cloud APIs (Run, Cloud Build, Artifact Registry, Vertex AI) before you can use them. Enabling an API costs nothing — you only pay for actual use.
Artifact Registry: Google Cloud's managed image storage. Cloud Build pushes the container image it builds for your site into Artifact Registry; Cloud Run pulls from it when a request arrives. You see a one-time prompt in step 6 to create a repository.
CLI (Command-Line Interface): A program you call by typing its name in a terminal instead of clicking. gcloud, npm, and git are all CLIs. Agents prefer CLIs when available — cheaper than MCP round-trips and the agent already knows shell.
Cloud Build: Google Cloud's managed build pipeline. When you run gcloud run deploy --source . it ships your code to Cloud Build, which builds the container image and hands it off to Cloud Run. You usually only see Cloud Build by name in failure messages — it links you to the build log when something breaks.
Cloud Console: The web UI for Google Cloud at console.cloud.google.com. Where you create projects, link billing, and inspect resources by clicking. Most workshop steps prefer the gcloud CLI, but the console is the authoritative place to find your project ID, billing status, and IAM roles.
Cloud Run: Google Cloud's serverless container platform. You give it a container image and a port; it gives you a public HTTPS URL that scales from zero. Pay per request, no machines to manage. Used to host the workshop site.
Codelab: Google's term for a short, hands-on tutorial — usually one focused hour. Free, browser-based or local, ends with something deployed or working. The wrap-up page links three relevant codelabs to deepen what you started today.
Commit: A labeled checkpoint in git — a snapshot of your code with a short note (git commit -m "fix login bug"). Every commit is a point you can return to later. Small frequent commits are the workshop's recommended rhythm: ask the agent for one change, review it, commit, repeat.
Container: A self-contained unit of software (your app + its OS dependencies + a runtime) that runs the same way on any host. Built from a Dockerfile, stored in Artifact Registry, and run on Cloud Run. The reason your site behaves identically locally and in production.
Context (in AI/LLM sense): Everything an LLM sees on a single turn: the user prompt, the system prompt, prior messages, tool results, and any files or documents pasted in. The model has nothing else to work with — anything outside the context is invisible to it. The art of working with LLMs is largely the art of choosing what goes into the context.
Context window: The hard cap on how many tokens an LLM can hold in mind on a single turn — typically tens or hundreds of thousands. Once full, older content drops out (or gets summarised). Why long sessions drift: early decisions slide out of the window and the agent quietly stops applying them. The fix is memory — promote durable facts into GEMINI.md or a spec file, so they re-enter the window every session.See also: Build with Antigravity, section 4
Context7: An MCP server that fetches up-to-date library documentation on demand. Lets an AI client query current API docs for libraries and frameworks instead of relying on its training data, which is often months or years out of date.
Deploy: Pushing your built code to a server so other people can use it. In this workshop, deploying means running gcloud run deploy --source . — Cloud Run takes your code, builds a container, and hosts it at a public HTTPS URL. The artifact you ship to recruiters.
Diff: The set of changes between two versions of code — what was added, removed, or modified. git diff shows it in your terminal; the agent shows it inline before applying. Reviewing the diff before accepting an agent's change is the core habit of agentic coding: the agent does the typing, you do the reviewing.
Dockerfile: The recipe Cloud Build follows to construct your container. The agent ships a small single-stage node:20-slim Dockerfile: copy files, npm ci, expose port 8080, run node server.js. You don't usually edit it — just understand what it does.
gcloud: The command-line tool for Google Cloud. You install it in step 1, sign in once, and use it to manage projects, enable APIs, and deploy to Cloud Run. The single most important CLI in this workshop.
GDE (Google Developer Expert): Google's volunteer expert program. People recognized by Google for deep expertise in a specific product area (web, AI, cloud, etc.) who run workshops, give talks, and bridge between the developer community and Google's product teams. This workshop is part of the GDE program.
Gem / Gemini Gem: A reusable Gemini configuration with a fixed system prompt and optional grounding. Think of it as a saved chatbot persona you can call repeatedly. The workshop uses a Gem to interview students for ~10 minutes and produce a structured YAML brief; that brief is then pasted into the workshop NotebookLM, which generates the Stitch and Antigravity prompts.
Gemini: Google's family of multimodal foundation models, plus the consumer chat product at gemini.google.com. In this workshop "Gemini" usually means the model family available through Vertex AI or the Gemini app.
git: Version control — the tool that tracks every change to your code over time. git init turns a folder into a tracked project; git commit creates a checkpoint; git diff shows what changed since the last checkpoint. Agentic coding leans hard on git: every agent edit becomes a reviewable diff, and you can roll back any change you don't like.
Guardrails: Constraints that catch the agent when it sprints in the wrong direction. Tests, types, lint, file-scope limits, "review before merge" rules, sandbox restrictions, tool-call review. The agent moves fast; guardrails decide whether that speed is useful or dangerous.
Hallucination: When an LLM produces output that sounds confident and plausible but is factually wrong — a fake API, a non-existent function, a made-up citation. Hallucinations are the main reason agentic coding still needs a human reviewer.
Harness engineering: Designing the system around the agent — feedback loops, observability, constraints, verification — rather than trying to perfect the prompt. The 2026 consensus: prompt engineering is solved; harness engineering is what separates a working demo from a system that ships.
Hook: A shell command the agent runs automatically before or after a tool call (Bash, Edit, Write, etc.), configured in .gemini/settings.json for Antigravity and Gemini CLI. Hooks make agent runs more deterministic: they observe (log every change), verify (auto-format, lint), or constrain (block destructive commands) — every time, regardless of what the prompt says. Where skills add capability, hooks enforce policy.See also: Build with Antigravity, section 3
IAM (Identity and Access Management): Google Cloud's permissions system. Defines which accounts can do which actions on which resources. The most common workshop gotcha: granting Cloud Build's service account the roles/run.builder role so it can create a Cloud Run service on your behalf.
JSON (JavaScript Object Notation): A text format for structured data — {"name": "Maya", "skills": ["Python", "design"]}. Used for persona.json in this workshop because it's the standard format for data exchange on the web. Compare to YAML: same shape of data, different syntax (YAML is easier to write by hand; JSON is what programs speak natively).
LLM (Large Language Model): The kind of AI behind Gemini and the agent in Antigravity. A model trained on huge amounts of text that predicts the next token given prior tokens. Everything you do in this workshop (Gem interview, Stitch design, Antigravity build) is an LLM responding to a prompt with structured output.
MCP (Model Context Protocol): An open protocol for connecting AI clients to external tools and data sources. An MCP server exposes tools and resources; an MCP client (Antigravity, Gemini CLI, custom agents) calls them. The standard way to extend a coding agent with custom capabilities.See also: Build an MCP server
Memory: Anything the agent can recall across sessions. Three layers, by time-horizon: standing (a small GEMINI.md at the project root, auto-loaded every session — conventions and constraints), ambient (auto-recall — facts the agent picks up about you, your stack, your past corrections, surfaced when relevant), and session-bridging (plans, specs, brainstorm docs you write together — read first by the next session, so today's decisions become tomorrow's context). Memory is what stops the agent from re-deriving the same decisions every turn.See also: Memory & context
Model: In this workshop, a specific LLM you can call by name — e.g. gemini-2.5-flash or gemini-2.5-pro. Models differ in speed, cost, context window, and quality. Names drift; the model you used last quarter may be deprecated this quarter.
NotebookLM: Google's source-grounded research notebook at notebooklm.google.com. You hand it a curated set of sources and the chat answers cite back to the original paragraphs — no fabrication. Used in step 2 to ground the workshop's Gem in research about strong portfolios.See also: Research with NotebookLM
OAuth: The authorization protocol Google (and most platforms) use to let one app access your data on another — Antigravity reading your Cloud Run service list, for example. When you "sign in with Google" and click "Allow", that's OAuth issuing a token the requesting app can use until it expires or you revoke it at accounts.google.com.
Orchestrator: The primary agent that delegates work to subagents. The orchestrator holds the plan, dispatches focused tasks, gathers results, and decides what's next. In agentic-coding tools like Antigravity and Gemini CLI, the agent you're chatting with is usually the orchestrator.
PATH: An environment variable that tells your shell where to find executables. After installing gcloud, the installer adds its directory to PATH so you can type gcloud from any folder. If gcloud: command not found shows up, PATH didn't update — open a fresh terminal window.
Permissions (in agentic-coding tools): Declarative rules in your agent's settings file — which tools auto-run without prompting, which paths the agent can write to, which environment variables it can read. Declarative because the rules are static and consulted before the agent acts (different from hooks, which fire imperatively on events). The pragmatic value: stops the agent asking permission for git status every five seconds. The right move for routine read-only operations; the wrong move for write/delete.See also: Plumbing reference
Persona JSON: The workshop's data file. A structured JSON document with your skills, projects, experience, and bio, produced by interviewing yourself with the Gemini Gem in step 3. Becomes the source of truth for the site's content and (in the bonus tracks) for the MCP server and chatbot.
Plans & specs: The session-bridging layer of memory. Plan documents, specs, brainstorm notes you write together with the agent during a session — saved as markdown files in the repo, read first by the next session. Today's decisions become tomorrow's context. The pattern: think → capture → reload. The agent forgets; the markdown doesn't.See also: Memory & context
Plugin: A bundle of skills, MCP servers, and config that extends a coding agent. In Antigravity, Gemini CLI, and frameworks like Superpowers, plugins are the unit of distribution — install one plugin and you get the skills and tools that come with it.
Project (Google Cloud project): The unit of organization in Google Cloud. Holds your APIs, services, billing link, and IAM permissions. Has a globally unique ID. One billing account can fund many projects; one project consumes credits from one billing account.
Prompt: The text you give an LLM to elicit a response. Includes the system prompt (instructions for the model's role) and the user prompt (the actual question or task). Prompt engineering is the practice of writing prompts that produce reliable output.
Prompt injection: A security attack where untrusted text the agent reads (a README, a webpage, a comment) contains hidden instructions that change its behavior. "Indirect" injection — the malicious instructions arrive via content the agent fetches, not via the user's chat. Treat external content as input, not as instructions.
Region: Where your Cloud Run service physically runs (and where Artifact Registry stores its image). Pick a region close to your users — europe-west1 for most of Europe, us-central1 for the US. Cloud Run remembers your default after the first deploy.
Scaffold (verb): To generate the initial files and folder structure for a project — the empty shells you'd otherwise create by hand. In step 5, Antigravity scaffolds your career site: it writes package.json, server.js, the public/ folder, the Dockerfile, and runs npm install. Scaffolding is the kind of mechanical work agents do well — copy-paste with judgement.
SDK (Software Development Kit): A bundle of libraries and tools for building against a platform. The Google Cloud SDK is what gets installed when you run the gcloud installer — it includes the gcloud CLI plus client libraries that local code (and your Antigravity-built site) can use to talk to Google Cloud.
Skill (in agentic-coding tools): A documented, triggerable capability the agent loads on demand. A skill bundles instructions, examples, and sometimes scripts. The agent picks skills based on the user's intent and runs them with full context. Different from a tool: skills tell the agent how to think; tools let it do things.
Spec-driven development (SDD): Write the spec before the code. The agent reads it, codes against it, and you both have something to compare results to. In this workshop, the Gem interview produces a YAML brief, NotebookLM turns the brief into a Stitch design prompt and an Antigravity build prompt grounded in regional research, and Antigravity then writes persona.json as part of the build — that's SDD applied to a personal site.
Stitch: Google's AI design tool for sketching app and site layouts from a prompt. Used in step 4 to produce the visual direction for your career site before any code is written.See also: Design with Stitch
Subagent: A second AI agent invoked by the primary agent for a focused task in a clean context. Subagents are how the orchestrator delegates: "go review this PR", "go run the tests and report". They isolate context so the parent doesn't get polluted with intermediate noise.
Superpowers: An open-source framework that codifies the spec → plan → execute → review → finish workflow as a curated set of skills (TDD, planning, code review, debugging, etc.) plus subagent orchestration and conventions for how a coding agent should behave. Not installed in this workshop — recommended as a follow-up for structured project work. github.com/obra/superpowers
System prompt: Instructions an LLM reads before every user message — they tell the model who it's pretending to be and what rules to follow. The Gem in step 3 has a fixed system prompt that enforces a one-question-at-a-time interview. The chatbot in step 9 builds a system prompt from persona.json so Gemini answers only as you. Different from a regular prompt: system prompts persist across the conversation; user prompts are per-message.
TDD: Test-driven development. Write a failing test, write the minimum code to make it pass, refactor, repeat. In agentic coding TDD is doubly useful: tests are how the agent knows it's done, and how you keep it honest about whether code actually works.
Token (in AI sense): The unit of text an LLM processes — roughly a syllable or short word, sometimes a whole word. "Hello world" is about 3 tokens. Models are billed and budgeted in tokens, and have a maximum number they can hold at once (the context window). "Token-efficient" means a tool returns information in few tokens; long sessions cost more because every turn re-reads everything in the context window.
Tool (in agent sense): Something the agent can do: read a file, run a shell command, call an HTTP endpoint, edit code. Tools come from the agent's host (Antigravity) or from MCP servers. Different from a skill: tools let the agent do things; skills tell it how to think.
TryGCP: Google's $5 trial billing account for workshops and short evaluations. Valid for 6 months, no credit card required, attached to a personal Gmail account. Funds the Cloud Run deploy in this workshop. Claimed via a per-event URL like trygcp.dev/claim/<event-id>.
Vertex AI: Google Cloud's managed platform for ML and generative AI. The way to call Gemini from a Google Cloud project with proper IAM, billing, and quotas. Used in the bonus chatbot step.See also: Add a chatbot
Vibe coding: Coined by Andrej Karpathy. Coding by prompting an LLM, accepting whatever it spits out, and shipping if it seems to work. Fast, fun, and fragile. The starting point most people experience before moving to agentic coding with structure, tests, and review.
YAML: A text format for structured data designed to be easy to read by hand. Uses key: value pairs and indentation instead of brackets — same data shape as JSON, gentler on the eyes. The Gem in step 3 outputs your interview answers as a single YAML block; NotebookLM reads it back without you having to edit anything.