Where to Go Next: The Learning Path Map

Tier 0 · Total Beginner 6 min read

You’ve installed Claude Code, logged in, run a session, made an edit, learned the safety prompts, and learned to read the output. That’s the whole of Tier 0 — you can now use the tool. This page is the map for everything after: what to learn next, in what order, and where it eventually leads.

How this track is organized

The learning track climbs in four tiers. Each builds on the last:

Tier 0 — Total beginner (you just finished this). What Claude Code is and how to run it.
Tier 1 — Fundamentals. The handful of concepts that separate “I can use it” from “I understand it”: sessions and context, files-as-state, CLAUDE.md, the built-in tools, prompting well, MCP, skills, hooks, and cost.
Tier 2 — Building. The patterns for going from one agent to many — spawning sub-agents, scheduling them, isolating their work, orchestrating them, and shipping their output safely.
Tier 3 — Everything built. Real, working pieces of a one-person agent system, each written up as a learning artifact: a self-healing loop, a memory layer, a web cockpit, an autonomous merch operator, and more.

You don’t have to finish a whole tier before peeking ahead. But the prerequisites are real — Tier 2 will assume you know what a tool and a CLAUDE.md are, and Tier 3 will assume you understand orchestration.

The recommended path

Next stop: Tier 1 — Fundamentals

These are the ideas that make everything else click. Read them roughly in this order:

Sessions & context windows

Why a session fills up, what “rotation” means, and when to start fresh. The thing that surprises every beginner: the agent’s working memory is finite.

Files as state, not chat memory

The single most important doctrine on this site. Anything that must outlive a session goes in a file. This is why the system can remember itself across thousands of sessions.

CLAUDE.md: teaching the agent your rules

A plain Markdown file the agent reads on startup. It’s how you give an agent standing instructions, conventions, and guardrails — without repeating yourself every session.

Tools 101

A closer look at the built-in hands — Read, Edit, Write, Bash, Grep — and how the agent decides which to reach for.

Prompting the CLI well

Ask for goals, not keystrokes. “Fix the bug, don’t refactor.” The scope-discipline that keeps diffs small and reviewable.

MCP, skills, hooks & cost

Giving the agent new senses (MCP), reusable commands (skills), automatic behaviors it can’t forget (hooks), and keeping the bill sane (model routing).

Then: Tier 2 — Building patterns

Once the fundamentals are solid, Tier 2 is where you stop running an agent and start running a system of them:

Anatomy of an agent — what a specialist agent looks like on disk (a folder + a command + its own state).
Spawning sub-agents — delegating a piece of work to another agent, in the foreground or background.
Worktree isolation — the hard-won lesson about why parallel agents need separate git workspaces, told through the real incidents that taught it.
Orchestration — a top-level agent routing work down to domain and specialist agents.
Loops: crons, watchers, sessions — the difference between “run every hour,” “fire once when X happens,” and “keep going until this job is done,” and how to pick.
Telegram & voice as a control plane — turning an agent into an always-on bot you talk to from your phone.
Root-cause-first & ship-to-prod — the build disciplines that keep a fast-moving system from collapsing under its own bugs.

Finally: Tier 3 — Everything built

Tier 3 is the gallery. Each article is one real, working piece of a single-operator agent system, documented honestly — what it is, why it exists, how it works, and where it’s still rough. It’s grounded in a real build: roughly 31 specialist agent packages, on the order of 155–160 scheduled jobs acting as the system’s heartbeat, a Supabase backend with 200+ tables, and 8 life-domain agents under one orchestrator. Highlights:

A self-healing loop that reads the system’s own error logs twice a day, writes ranked fix proposals, and — after a human approves — has isolated build agents ship the fixes with regression guards.
An autonomous merch operator that designs, lists, and fulfills products, with money, identity, and trademark sign-off hard-walled to a human. It proved a real first sale end-to-end (and surfaced three live bugs on that first order — documented, not hidden).
A hybrid memory layer, a deep-research agent, a web cockpit for watching the whole thing, and the open-sourced tools spun out along the way.

The honest expectation

This is not a “10x your productivity overnight” track. The path from here to running your own system of agents is real work, and the Tier 3 stories are upfront that the impressive parts are also messy, single-operator, and held together by deliberate discipline. The point of the map isn’t to rush you to the end — it’s so that when you land on an advanced article, you have the ideas underneath it to actually understand what you’re reading.

Start here

Pick up Tier 1 — Sessions & Context Windows when you’re ready. Take the tiers in order, build small things as you go, and come back to this page whenever you’re unsure what’s next.

You’ve finished Tier 0. You can install Claude Code, log in on the right billing, run a session, make and review edits, stay safe with permissions, and read what the agent is doing. That’s a real foundation. Everything after is just more tools, more memory, and more agents — the same loop, scaled up.