Where to go next: learning paths

You can install Claude Code, sign in on the right billing, run a session, review an edit, and read what the agent is doing. That's the whole of Start here. This page is the map for everything after: four reading paths, each in order, picked by what you're trying to do.

These docs moved from docs.agenttree.army to jddavenport.com/docs in October 2026, and every article was rewritten for the move: current facts, current commands, and the parts that were wrong taken out. If you followed a link from the old site, you're in the right place.

#How the docs are organized

You don't have to finish a section before peeking ahead. The prerequisites are real, though: Patterns assumes you know what a tool, a hook and a CLAUDE.md are.

#Path 1: your first week with Claude Code

For: you just installed it and want to use it well on your own projects. Read in order, and do something small with each one before moving on.

1. Sessions and context windows
2. Files as state, not chat memory
3. CLAUDE.md: teaching the agent your rules
4. Tools 101
5. Prompting Claude Code well
6. Git discipline for agents
7. settings.json and permissions config
8. Cost and model choice
9. Build your first agent

By the end you'll have a small agent that runs on a schedule, keeps its memory in a file, and follows one safety rule: it drafts, it doesn't send.

#Path 2: from one agent to many

For: you've got one useful agent and want several working together without stepping on each other. This is where most of the hard lessons live.

1. MCP: giving the agent new senses
2. Skills
3. Hooks: rules the model cannot forget
4. Anatomy of an agent
5. Write the spec before the code
6. Sub-agents and delegation
7. Worktree isolation: the hard lesson
8. Orchestration: delegate down, verify up
9. Model routing
10. Agent memory you own
11. The loops doctrine, then Schedules as a heartbeat and Watchers
12. Root cause first
13. Ship to prod

If you only read three: worktree isolation, hooks, and ship to prod. Those three prevent most of the damage I've seen agents do.

#Path 3: how a production AI organization runs

For: you want to see the whole thing working. This is my own system, the Nerve Center: 30+ agents in daily production since April 2026, with the failures left in.

1. The architecture in one page
2. How the system got built
3. The CEO agent and Domain agents
4. The agent bus
5. Fleets: parallel build agents
6. The second brain and Open loops
7. The cockpit and The bridge
8. One door out: the send gate
9. QA: user stories, Playwright and synthetic users
10. Auto bug-squash and the Warden
11. Watchdogs: liveness is work completed
12. Durable state

For the short version first, read the production teardown on my site. The system also publishes its own census daily on the live capabilities page.

#Path 4: for PMs and leaders

For: you're deciding what AI means for your role or your team, and you'd rather learn from a running system than a slide.

1. The AI product builder
2. Agent evals, the first AI Core Skill, and the one I'd learn first
3. One door out: the send gate
4. The system documents itself
5. Lessons from running agents every day
6. Why agents will eat a lot of SaaS
7. Building in public without fooling anyone
8. How to break into product management and The MBA path, if you're making the move yourself

#Browsing instead

Not every reader wants a path. The Builds section is case studies you can read in any order, and Open-source index lists every public repo behind these docs. New term? The Glossary defines it.

#The honest expectation

This isn't a "10x overnight" track. Getting from one session to a system of agents you trust is real work, and the parts of my system that look impressive are also the parts that broke most often. The paths exist so that when you hit an advanced article, you have the ideas underneath it.

Take them in order. Build small things as you go. Come back here when you're not sure what's next.

Next: Sessions and context windows