Learn by Doing — Exploring the Three Surfaces

Lab 0 — First Contact with Antigravity

A warm-up before we build StackLog

Goal: meet the three surfaces of Antigravity and map each back to the agent loop (Perceive → Reason → Act → Remember).

You won't build the real app yet. You'll learn where things live and what an agent actually looks like when it works.

How This Worksheet Works

• Each step has an action and a ✅ checkpoint — don't move on until the checkpoint passes.
• 🔎 Observe boxes tell you what to notice (this is the real learning).
• 🧠 Map it boxes connect what you see to the agent anatomy.
• ⚠️ Check current UI = Antigravity updates often; the label may differ — find the equivalent.
• 🙋 If a checkpoint fails, flag it now. Don't fall behind silently.

⚠️ Important Day-Of Note

Antigravity ships three things with similar names. Know which is which:

1. Antigravity IDE — the VS Code–style editor (you + agent code together)
2. Antigravity App / Manager — the standalone "mission control" for orchestrating agents
3. Antigravity CLI (the agy command) — terminal-native agent invocation

The old Gemini CLI is being retired — make sure you installed the Antigravity CLI, not gemini. We verify this in Step 1.

Pre-Flight Checklist

Before the lab clock starts, confirm you have:

• [ ] Antigravity installed (IDE + App) and signed in with your Google account
• [ ] Antigravity CLI on your PATH
• [ ] Node.js v20+ (node -v)
• [ ] A terminal open
• [ ] A scratch folder for today: mkdir agentic-warmup; cd agentic-warmup

✅ Checkpoint 0: All five boxes ticked. If not, raise your hand now.

Part A — The CLI Surface

Where the agent lives in your terminal

We start here because the CLI is the most transparent surface — you see the raw agent loop with nothing hiding it.

A1 — Verify the CLI

Action: In your terminal, check the CLI is the Antigravity one.

agy --version

⚠️ Check current UI: the binary is agy. If your muscle memory types gemini, stop — that's the retired tool.

✅ Checkpoint A1: A version number prints, and it's Antigravity (not Gemini).

🔎 Observe: You're about to talk to an agent without any IDE. Same brain, no window dressing.

A2 — Give the Agent a Tiny Goal

Action: Ask the agent to do something small and observable in your scratch folder.

agy -p "create a file called hello.txt containing a haiku about autonomous agents"

-p (--print) runs the prompt once, non-interactively, and prints what the agent did — and it still creates the file. Prefer to watch the loop turn-by-turn? Use the interactive form agy -i "…" (exit with Ctrl-C).

⚠️ Version drift: Antigravity moves fast — if a flag errors, run agy --help and use the print/prompt form it lists.

✅ Checkpoint A2: hello.txt now exists. Run cat hello.txt to confirm.

A3 — Watch the Loop Happen

🔎 Observe what the CLI printed between your command and the result:

• It planned (decided what to do)
• It called a tool (wrote a file) — possibly asking your approval
• It reported what it did

🧠 Map it:

✅ Checkpoint A3: You can point to where each of the four components happened.

A4 — Force a Self-Correction

Action: Give it a goal that will fail first, so you can watch it recover.

agy -i "run the script start.js"

(There is no start.js yet — that's intentional.)

-i (--prompt-interactive) keeps the session open so you watch the recovery happen live — the right mode for A4. Give it a moment to investigate, then exit with Ctrl-C. (Scripted one-shot alternative: agy -p "…", which runs silently then prints a summary — handy, but you don't see the loop.)

🔎 Observe: the agent hits an error, reads the error, and decides what to do (often: tells you the file is missing, or offers to create it — it may even write start.js and run it).

🧠 Map it: reading the error = Perception of the result of its own Action. That feedback is the loop closing. This is exactly the "self-correction = the loop running more than once" idea from this morning.

✅ Checkpoint A4: You witnessed the agent react to a failure rather than crash blindly.

Part B — The IDE Surface

Where you and the agent code together

The CLI showed the loop bare. The IDE wraps it in a workspace so the agent can see your whole project and act across many files.

B1 — Open the Project in the IDE

Action: Open the Antigravity IDE and open your agentic-warmup folder.

⚠️ Check current UI: File → Open Folder (it's a VS Code fork, so this is familiar).

✅ Checkpoint B1: You can see hello.txt from Part A in the file tree. Same folder, new surface.

🔎 Observe: the agent now has a richer Perception — it sees your entire file tree, not just one command's worth of context.

B2 — Find the Two Views

🔎 Observe: Antigravity gives you (at least) two ways to work:

• Editor View — looks like VS Code; you and the agent edit together
• Manager / Agent view — where you watch the agent work on tasks

⚠️ Check current UI: names and panel positions vary by version. Find: (a) the code editor, (b) the place where you give the agent a task and watch its plan.

✅ Checkpoint B2: You've located both the editor and the agent task panel.

B3 — Give the Agent a Multi-File Goal

Action: In the agent panel, give a goal that touches more than one file:

Create a minimal Node script app.js that reads hello.txt and prints
its contents in uppercase, plus a package.json so it can run.

🔎 Observe: the agent now plans across files — it proposes creating/editing several things. Notice it shows you a plan / artifact before or as it acts.

⚠️ Check current UI: depending on your agent mode (autonomy level), it may pause for your approval. That pause is a feature — approve steps deliberately.

✅ Checkpoint B3: Both app.js and package.json exist, created by the agent.

B4 — Run It and Let the Agent See the Result

Action: Run the script in the IDE's integrated terminal.

node app.js

🔎 Observe: the terminal is a surface the agent can read. If it errors, you can hand the error straight back to the agent ("fix this") and watch it self-correct — same loop as A4, now inside the IDE.

🧠 Map it: IDE = the agent acting on the code surface; terminal = the agent perceiving runtime reality. Two surfaces, one loop.

✅ Checkpoint B4: node app.js prints the uppercase haiku. If it errored and the agent fixed it — even better; you saw the loop close.

Part C — The App / Manager Surface

Where you orchestrate agents, not files

The IDE is for you + one agent + code. The App is mission control — many agents, many tasks, you supervising.

C1 — Open the Manager

Action: Open the standalone Antigravity App (Manager).

⚠️ Check current UI: this is a separate application from the IDE in 2.0. Launch it on its own.

✅ Checkpoint C1: You see a dashboard for tasks/agents, not a code editor.

🔎 Observe: the mental model flips. In the IDE you watch code. Here you watch agents and their progress.

C2 — Start a Task and Watch It Run

Action: Start a new task/conversation pointed at your agentic-warmup workspace. Give it something self-contained:

Add a README.md to this project explaining what app.js does.

🔎 Observe: the Manager shows the agent's plan, steps, and artifacts at a "task" level of abstraction — higher up than line-by-line code.

🧠 Map it: the Manager is built for asynchronous supervision — you set direction, the agent works, you review artifacts (its outputs) rather than every keystroke. This is the "architect, not coder" shift made literal.

✅ Checkpoint C2: README.md exists, and you watched it appear as a tracked task with reviewable output.

C3 — Notice the Knowledge Base

🔎 Observe: Antigravity can save useful context to a knowledge base to improve future tasks.

🧠 Map it: this is durable Memory — the cross-cutting layer from our anatomy discussion. The agent isn't starting from zero each time; it accumulates and reuses context.

✅ Checkpoint C3: You can locate where Antigravity stores learned context / past task history.

⚠️ Check current UI: feature name and location vary — look for "knowledge," "memory," or task history.

Part D — Tie It Together

Three surfaces, one agent loop

D1 — The Surface ↔ Loop Map

🧠 Fill this in from what you did today:

✅ Checkpoint D1: You can say, in one sentence each, when you'd reach for each surface.

D2 — The Big Realization

🔎 Observe: across all three surfaces, it was the same agent loop.

• Same Perceive → Reason → Act → Remember
• Different form factor for how you interact with it
• The CLI didn't hide the loop; the App raised the abstraction above it

The surface changes how you work. It does not change what the agent is.

D3 — Where StackLog Comes Next

This was the warm-up. You now know where to stand. Next:

• We'll build StackLog as a real agentic app
• The agent's Action capabilities on its data will come from a custom MCP server — the thing we build next
• You'll drive it across all three surfaces you just explored

✅ Checkpoint D2 (final): You've created files via CLI, IDE, and App; you can map each surface to the loop; you're ready to give the agent real, custom tools.

Lab Retro — 3 Questions

Discuss with your neighbor:

1. Which surface felt most transparent? Which felt most powerful? Why aren't those the same?
2. Where did you see the agent self-correct? What did it perceive to do that?
3. The agent could write files today. Who decided what it was allowed to do? (Hold that thought — it's tomorrow's whole point: MCP.)

If You Finished Early

Stretch goals:

• Run the same goal in two different surfaces — compare how it's presented.
• Switch the agent's model (Gemini / Claude / other) and rerun a task — notice any difference in plan style.
• Try a deliberately ambiguous goal ("make this project nicer") and watch how it reasons under uncertainty.

⚠️ Check current UI: model switching location varies — look in settings or the task/agent panel.