00 — Why This Layer Exists
Everything in Layer 02 happened inside someone else's walled garden. The no-code AI app builders you tried — hosted platforms that generate an app from a prompt — hide the actual code, manage the server, and make "undo" a button in a friendly UI. That's their whole value: you never touch the machinery.
This layer is different. Here you install a tool onto your own laptop, open (or create) an actual folder of files, and let an AI agent read, write, run, and delete things inside it. There is no platform standing between you and the mess you can make. The upside is enormous: you can now work on any codebase, in any language, integrate with any API, and take an app anywhere — mobile, backend, automation scripts, whatever's next in this series. The downside is that "undo" is no longer a button. It's a discipline (specifically: git, which you'll learn to lean on below).
The term you'll hear constantly is agentic. A simple autocomplete tool (the old GitHub Copilot, circa 2022) watches you type and finishes your sentence — one file, one line, no memory of the rest of your project. An agentic tool is given a goal in plain English ("add a password-reset flow"), then plans multiple steps, reads across many files to understand your project, writes and edits code itself, runs terminal commands, executes tests, and iterates on failures — largely on its own, with you approving or interrupting along the way. That leap — from "finish my sentence" to "go do the task" — is what this whole layer is about.
01 — What "Agentic" Actually Means, Concretely
When people say a tool "has agent mode," they mean it can do some combination of:
- Read your whole codebase, not just the open file, to understand context before acting.
- Plan a multi-step task ("refactor this, then update the tests, then update the docs") rather than complete one line.
- Edit multiple files in one pass, and show you a diff (a side-by-side view of exactly what lines changed) before or after applying it.
- Run commands in a terminal — install packages, run your test suite, start a local server — and read the output to decide its next move.
- Use git — the version-control system that snapshots your project's history — to stage changes, write commit messages, or open pull requests.
- Loop on failures: if a test fails or a command errors, a genuinely agentic tool feeds that error back into its own reasoning and tries again, instead of just handing you a static suggestion.
Every tool in this layer offers some version of this. They differ in where they live (a full editor vs. a terminal vs. a plugin bolted onto your existing editor), how autonomous they let you get, and how they charge you for it.
02 — The Landscape (as of September 2026)
| Tool | What it is | Current pricing | Best for | Learning curve |
|---|---|---|---|---|
| Claude Code | A terminal-first agentic coding tool from Anthropic — also available as a VS Code/JetBrains extension, a desktop app, and a browser version at claude.ai/code. Reads your repo, edits files, runs commands, uses git, opens PRs. | Bundled into Claude subscriptions: Pro $20/mo (light use, shared with regular Claude usage), Max 5× $100/mo (daily development), Max 20× $200/mo (heavy/agentic work); Team seats from ~$100/seat/mo; pay-as-you-go API pricing also available. | PM-coders who want the most "do the whole task" autonomy, comfortable typing plain-English instructions into a terminal or the desktop app. | Steepest at first (a command line is unfamiliar to a non-coder) but the plain-English interaction makes it forgiving once you're past that. |
| Cursor | A full standalone code editor (a fork of VS Code) with AI agent features — "Composer" and multi-file agent mode — built directly into the interface. | Hobby free (limited agent use); Pro $20/mo; Pro+ $60/mo; Ultra $200/mo (same features as Pro, larger usage pools); Teams from $40/user/mo. | Beginners who want a visual, point-and-click editor rather than a terminal, with the AI woven into normal file-browsing and editing. | Gentle — it looks and feels like a familiar code editor with a chat panel; the "agent" is one more thing you click. |
| Windsurf (now "Devin Desktop") | Formerly an independent AI-native editor; acquired by Cognition (maker of the Devin coding agent) in mid-2025. As of June 2026 it auto-updated into Devin Desktop, an "Agent Command Center" that manages multiple coding agents (including its own Devin agent) inside the same editor shell. The old Windsurf name and standalone Cascade agent are being phased out. | Free tier; Pro $20/mo; higher Max tier for power users; Teams/Enterprise available — pricing carried over from Windsurf largely unchanged through the rebrand. | People who want one dashboard to launch and monitor several AI agents on different tasks at once, rather than a single assistant. | Moderate — the interface now leans toward "managing a fleet of agents," which is a step up in complexity from a plain chat-with-your-editor tool. |
| GitHub Copilot | Microsoft/GitHub's AI pair programmer — started as autocomplete, now includes an agent mode inside VS Code, Visual Studio, JetBrains, Eclipse, and Xcode, plus a cloud coding agent and CLI. | Free (2,000 completions/mo, limited chat/agent, access to smaller models); Pro $10/mo (unlimited completions, agent mode, $15 of monthly AI credits, can even run Claude Code or OpenAI Codex through it); Pro+ $39/mo ($70 credits, premium models); Business/Enterprise and a Max tier at $100/mo for heavy users. | Anyone already living inside VS Code or a JetBrains IDE who wants agent capability layered onto a tool they already use, at the lowest entry price. | Gentle if you already use VS Code; agent mode is a toggle, not a new tool to learn. |
A note on volatility: this table is accurate for September 2026, but every one of these products has changed its pricing or its name within the last year (Windsurf's rebrand being the most dramatic example). Before you commit money, check the tool's own pricing page — don't trust a guide, including this one, to still be current in six months.
03 — How This Differs From Layer 02's No-Code Builders
In Layer 02, you described an app and a hosted platform built it for you, inside its own system, using its own conventions. You could preview it, but you generally couldn't open a terminal and see the raw files, and "the codebase" wasn't really your concept to manage.
Here, three things change at once:
- You own a real folder of files. Nothing is hidden. You can open any file in a text editor and read the actual code, even if you don't understand it yet.
- You're working in a real IDE or terminal, the same tools professional engineers use — not a simplified builder UI designed for non-coders.
- Version control (git) becomes your safety net, not the platform's autosave. In Layer 02, "undo" was built into the product. Here, undo is a skill: you commit checkpoints yourself, and if an agent makes a mess, you revert to the last commit.
This is a genuine step up in power and in responsibility. You can now build things no no-code builder supports — custom backends, unusual integrations, mobile app code, anything covered in later layers of this series. But the AI can also now do real damage to real files if you let it run unsupervised on something you haven't backed up.
04 — A Safe First Session: Step by Step
This is the workflow to actually follow the first several times you use any of these tools.
- Install the tool and open a small, low-stakes project first — not your most important work. A toy project or a copy of something you don't mind breaking is ideal for session one.
- Make sure the project is a git repository, and commit before you start. If you don't already have git set up, this is the moment to learn the three commands that matter most:
git status(what's changed),git add+git commit -m "message"(save a checkpoint), andgit log(see your history). Commit before you let the agent touch anything — that commit is your restore point. - Ask for one small, specific thing, not "build me a whole feature." Something like "add a loading spinner to the submit button" is a good first task. Avoid "refactor the whole app" or "add authentication" on day one — big asks produce big diffs, and big diffs are exactly what you can't review carefully yet.
- Watch for the diff. Every one of these tools will show you a preview of the files it wants to change before (or immediately after) it changes them. Read it, even the lines you don't fully understand. Look for: does this touch only the files you expected? Does it delete anything you didn't ask it to delete?
- Approve in small steps rather than granting broad "auto-run everything" permission the first few sessions. Most of these tools let you approve each file edit or command individually at first — use that. Loosen the leash only once you trust the pattern of what the tool tends to do.
- Run the app or the tests yourself after the change, even if the agent says it already did. Seeing it work with your own eyes is the actual check.
- Commit again once you're happy with a working state, with a clear message describing what changed. That new commit becomes your next restore point.
- If something goes wrong, revert — don't try to prompt your way out of a mess.
git checkout -- .(discard uncommitted changes) orgit reset --hard <last good commit>gets you back to solid ground faster than asking the AI to "undo that." (Note:git reset --hardpermanently discards uncommitted work, so use it only when you're sure you want to throw the current changes away.)
Repeat that loop — small ask, review diff, test, commit — and you build both a working app and your own judgment about what these tools are reliable at.
05 — Common Mistakes Beginners Make
- Accepting a huge diff without reading it. If an agent proposes changes across fifteen files after a one-sentence prompt, that's a signal to stop and ask it to break the task into smaller pieces — not to click "accept all."
- Skipping git entirely. Working without commits means your only undo option is asking the AI to "put it back," which is unreliable. Commit early, commit often.
- Over-trusting confident-sounding output. These tools state incorrect things with the same tone as correct things. A change that "looks done" and a change that actually works are not the same — always run it.
- Granting full auto-run permissions in week one. Letting an agent execute any command it wants, unsupervised, before you've seen its typical behavior on your project is how a small task turns into a deleted file or a broken dependency.
- Treating the tool like the Layer 02 builders — assuming there's always a clean "revert to previous version" button. Some of these tools have session history or checkpoints, but git is the reliable, tool-independent backup. Don't depend on a vendor feature you haven't verified exists.
- Jumping straight to the biggest, most expensive plan. Every tool above has a free or $20/month tier sufficient for learning the workflow. Start there; upgrade once you know how much you actually use.
06 — When to Make the Jump from Layer 02
Move here once any of these is true: you've hit a wall a no-code builder can't cross (a custom integration, a data model it doesn't support, a performance issue you can't configure away); you want to actually own and host your code instead of renting it inside a platform; you're planning to add a mobile app, backend service, or automation that spans multiple systems (topics in later layers); or you simply want to understand — even at a beginner's level — what's actually running your product, because you're the PM who'll be making calls about it. If none of that resonates yet, staying in Layer 02 longer is a perfectly good choice — this layer adds real power, but also real responsibility for the code you now own.
Where this leads
Right now, every session in this layer starts from a blank folder or an existing mess — you're describing what you want and hoping the agent builds sensible foundations each time. Layer 04, Templates & Starter Stacks, fixes that by giving you pre-built, battle-tested project skeletons — authentication, database, styling, and deployment already wired together — so your agentic coding tool has a solid structure to work within instead of inventing one from scratch every time. That's the difference between an agent improvising architecture and an agent filling in a proven blueprint.