🧭 Fundamentals

A Google code editor powered by AI agents that runs on your machine and edits real files — you give it instructions in natural language.

It's the most direct way to move beyond "dragging blocks" and build complete applications without mastering syntax.

Agents · natural language · local environment · Gemini 3 Pro / Claude / other models.

A mental map: top = visual tools (Make/n8n), middle = cloud vibe coding, base = local environment (AntiGravity).

Knowing which layer you're in helps you choose the right tool and understand what each one sacrifices.

Abstraction vs. control · cloud simplifies at the cost of functionality · local = full control.

Deterministic = a fixed, repetitive workflow (ideal for Make/n8n). Agentic = AI writes and manages code for changing problems.

The question “does this change or is it always the same?” determines which approach to use.

Fixed workflow · adaptive workflow · complexity · autonomy.

Every visual tool is just an interface over code. Mastering code (with AI) is the foundation that won’t become obsolete.

It makes you immune to the fear of “the next trendy tool”—you’re already at the layer that does it all.

Interface vs. foundation · skill longevity.

Cursor, Windsurf, and AntiGravity are competing AI IDEs. The course uses AntiGravity, but the principles apply to all of them.

You learn a concept, not a button — and can switch tools without starting over.

Native capabilities · skill portability.

For simple, repetitive, and stable tasks (e.g., “filled form → add to list”), a no-code workflow is faster and cheaper.

Using the right tool saves time — not everything needs to become an app.

Cost-effectiveness · simplicity · maintenance.

Each module includes concepts, step-by-step instructions, an example, an exercise, and ready-to-use prompts. Mark each section as read to track your progress.

Knowing the structure helps you study methodically and pick up where you left off.

Saved progress · prompt library · hands-on practice.

Visual workflows with fixed steps: trigger → action → action. Great for predictable tasks that don’t change.

It's the simplest and cheapest way to solve repetitive problems.

Trigger · modules · webhook · predictability.

You describe the goal, and AI writes/edits code, tests, and fixes it — for complex, evolving problems.

Unlocks what a fixed workflow can’t handle: complete apps and unlimited functionality.

Autonomy · adaptation · generated code.

Visual tools are a polished layer over JSON/code. Copy a workflow and you can see the JSON behind it.

Understanding this demystifies “code” and shows that you were already working with it without realizing it.

Abstraction layer · JSON · visual interface.

A decision guide: simple, stable task → no-code; complex problem with its own interface and logic → agentic app.

Avoids using a cannon to kill a fly (or vice versa).

Selection criteria · cost · complexity.

No-code and agentic apps complement each other; understanding workflows makes you better at directing agents (and vice versa).

You gain a broader range of solutions.

Complementarity · breadth of experience · integration (MCP).

Cloud vibe coders are like an IKEA house: they deliver something ready-made, but with fixed structures. Locally, you can build however you want.

Shows the trade-off between speed and freedom.

Convenience vs. control · cloud limits.

Download and install the app from the official site (antigravity.google).

It’s the first concrete step—without it, nothing runs.

Official download · installation.

Node.js is the "engine" that lets AI create and run projects at the level of your computer.

Without it, the agent can't run most apps locally.

Runtime · npm · local environment.

GitHub is where files are stored and versioned. Repositories can be public (anyone can see them) or private.

It's where you import projects and where you publish yours.

Repo · visibility · collaboration.

Import a repo (by pasting the URL) and ask it to run — it starts up at a local address (localhost) that only you can see.

It's the basic cycle: bring in code, run it, see it on screen.

Import · localhost · preview.

The terminal is how you communicate with the computer using text: install things, run commands, perform actions.

Many actions (installing packages, running builds) go through it.

CLI · command · installation.

Rule of thumb: one model strong in design for layout, another strong in reasoning for code and troubleshooting.

Choosing the right model greatly improves the results.

Model selection · use case.

Command panel, file navigation, “publish to GitHub,” and Agent Manager (where you manage multiple agents).

Getting to know the interface speeds up everything that comes next.

Panel · Agent Manager · workspaces.

The agent opens the browser, clicks buttons, checks the result on screen, and corrects itself — with no extra plugins.

It’s an advantage that saves a lot of back-and-forth.

Browser control · self-correction.