The path, at your pace

Groundwork Twelve.

Twelve stages from zero to AI-native development habits: terminal, tmux, Git, an editor, real programming, data, the web, and directing agents. Run it steady in twelve weeks, committed in six, or immersed in under a month — same sequence, same gates, your hours.

Groundwork Twelve combines pieces that are usually separate: from-zero tool fluency, a session-by-session plan, hours-deep practice that builds muscle memory, honest progress measurement, and directing AI agents as a first-class skill. It sequences the pages already in this guide — each session tells you what to do, how long it takes, and where to read.

It's written in layers, like everything here. If you already know a stage's material, take its gate check first: pass it and move on, and let the plan slow you down only where your fingers (not your understanding) need the reps.

#Pick your pace

The plan is 60 core sessions and 12 builds, organized into 12 stages. A stage ends at a gate check — you advance when you pass it, not when the calendar says so. Pace decides how many sessions you run per day and how deep each day goes. More hours don't just finish sooner; they compound into more total practice, and the hours are the product.

#The shape of a day

Every core session has the same four slots, about an hour together:

At Steady pace, one session is the day, the build is Saturday, and Sunday is rest or catch-up. At Committed and Immersed pace, sessions nest inside a bigger day. The immersed day is designed the way gamers actually play — an hour of new mechanics, many hours of play:

Life happens at every pace, so every calendar day has three modes. The streak survives as long as you do the minimum:

#Let the agent run the schedule

Three presets can't capture "90 minutes on weekdays, ten hours on Saturday" — but your agent can, trivially. The log-repo scaffold ships a machine-readable syllabus.md (all 60 sessions, drills, builds, and gates) and a prompts/scheduler.md. Each day, tell the agent your hours; it reads your log and the syllabus and serves a plan sized to exactly the time you have — including which old drills are due for their spaced repeat. You declare intent; it does the bookkeeping. That's the whole Groundwork thesis in miniature.

$ cd ~/groundwork-log && claude
> Use prompts/scheduler.md. I have 6 hours today.

#Play your way through it

If games are what keep you coming back, real ones exist for most of these skills — legitimate substitutes for drill slots and first-class citizens of the immersed drill & game block (never substitutes for the build):

#How progress is measured

Four layers, no gimmicks. No points, no badges, no timers — artifacts, observable skills, and gates.

The log template

Session 1 creates ~/groundwork-log. Start log.md with this — pace declared up top, one line per day:

# Groundwork Twelve — my log
Pace: immersed (~9h/day) — declared 2026-07-07, revisit anytime

Day 1 (2026-07-07): Sessions 1+2, bashcrawl cleared, build started. 9h. Hands tired, hooked.
Day 2 (2026-07-08): Session 3+4, Bandit 0-5. The rm scare happened. 8h.
Day 3 (2026-07-09): Minimum day — one drill, this line. 15m. Life happened; streak lives.

At every gate, add a short review under a heading: what got easier, what still feels slow, one thing to repeat. Honest beats impressive — the log is for you. (Restarting on a new machine later? new-twelve-log scaffolds the repo with all the templates in place.)

The examiner prompt

At each gate check from Stage 4 on, start your agent in the log repo and paste this — it ships in the scaffold as prompts/examiner.md:

Read log.md and this stage's files. You are my examiner, not my helper.
Give me five small tasks that test this stage's skills, one at a time,
and wait for me to do each in my terminal and report back.
Don't show me how. After the five, tell me: what am I avoiding,
what should I repeat next stage, and one thing I did well.

#Agent rules by phase

The agent is present from Session 1 — but what it's allowed to do grows as your fundamentals harden. This ladder is the heart of the plan: an agent that does the work for you in Stage 2 quietly robs you of the practice that makes Stage 10 possible. Each session below has an Agent: line applying these rules; state your phase when you start a session.

#The arc

#Stage 1 — Keyboard, terminal, and your log

Steady: week 1Committed: ≈ days 1–4Immersed: ≈ days 1–2

Reading: Getting started. Everything happens in the terminal from the first minute. Agent phase: explainer.

Gate check 1 — without the cheat sheet: navigate anywhere and back; create, move, and delete a file; recall a command with CtrlR; start, split, detach, and reattach tmux; a commit in your log for every day so far.

#Stage 2 — The daily drivers

Steady: week 2Committed: ≈ days 4–7Immersed: ≈ days 3–4

Reading: Shell & CLI. Clone a real project to explore: git clone https://github.com/jasondockery/groundwork ~/code/groundwork-explore. Agent phase: explainer.

Gate check 2: find any file by name and any string by content in a repo you've never seen; jump between three projects with z; resurrect yesterday's commands without retyping them.

#Stage 3 — tmux and the machine

Steady: week 3Committed: ≈ days 8–11Immersed: ≈ days 4–6

Reading: tmux, plus macOS desktop and Keyboard. On Linux/WSL, swap Session 14 for your window manager's equivalents — the tools are choices; the keyboard-first habit is the point. Agent phase: explainer.

Gate check 3: cold start to full workspace in one command; move between editor, terminal, and browser without touching the mouse; survive a detach in the middle of real work.

#Stage 4 — Git for real

Steady: week 4Committed: ≈ days 11–14Immersed: ≈ days 6–7

Reading: Git. The Session 1 ritual becomes understanding. Agent phase: reviewer — from now on, end each session asking it to critique your commits.

Gate check 4: stage half a file with add -p; explain what HEAD is in one sentence; undo an unstaged change, a staged change, and a bad commit; branch and merge without consulting anything.

#Stage 5 — The editor

Steady: week 5Committed: ≈ days 15–18Immersed: ≈ days 8–9

Reading: Neovim. If you've chosen VS Code or another editor, do the same drills with its keyboard equivalents — fluent editing is the requirement; the editor is your choice. Agent phase: reviewer.

Gate check 5: make five common edits without arrow keys or mouse; open any file by fuzzy name; move between editor and terminal panes without thinking about it.

#Stage 6 — Pipes, scripts, and publishing

Steady: week 6Committed: ≈ days 18–21Immersed: ≈ days 9–11

Reading: Command line & Unix, and the remote sections of Git. Agent phase: reviewer.

Gate check 6: compose a pipeline from scratch to answer a question; write, run, and lint a script; push a branch and open a PR without looking anything up.

#Stage 7 — Programming, by hand

Steady: week 7Committed: ≈ days 22–25Immersed: ≈ days 11–13

Python via uv — the interpreter is already managed for you (Development). Agent phase: bounded pair — it may implement after you've written a spec or failing test. Not before.

Gate check 7: write a loop, a dict lookup, and a function from a blank file; make a failing test pass; read a traceback bottom-up and say what it means before fixing it.

#Stage 8 — Data: tables and documents

Steady: week 8Committed: ≈ days 25–28Immersed: ≈ days 13–14

Reading: Data & storage — foundational forever: every real app is data plus rules about who can change it, and agents write data code you must be able to judge. Agent phase: bounded pair.

Gate check 8: create a table and query it with WHERE/GROUP BY from memory; run the SELECT-before-UPDATE ritual unprompted; explain tables-vs-documents in two sentences using your own data as the example.

#Stage 9 — The web: HTTP and a real app

Steady: week 9Committed: ≈ days 29–32Immersed: ≈ days 15–16

How programs talk: requests, responses, JSON over the wire. Agent phase: bounded pair.

Gate check 9: explain request/response and a status code in plain words; fetch, store, and serve the same piece of data; find your way around a codebase you've never seen well enough to describe one file's job.

#Stage 10 — Directing agents on narrow work

Steady: week 10Committed: ≈ days 32–35Immersed: ≈ days 16–18

Reading: Editors & AI — the loop, concrete targets, and knowing your budget. This stage the skill under practice is direction. Agent phase: bounded pair, deliberately exercised.

Gate check 10: run the full loop without skipping review; produce a red test an agent can work from; notice a polluted context before it costs you an hour.

#Stage 11 — Repo scale: specs, delegation, verification

Steady: week 11Committed: ≈ days 36–39Immersed: ≈ days 18–20

Reading: AI agents & rules, Starting a project, and the security chop on the agentic engineering page. Agent phase: delegate — bounded tasks end to end. You own the merge.

Gate check 11: a fresh agent session follows your AGENTS.md without coaching; you catch a plan-reality divergence before merge; the SELECT-before-write and risk-naming habits fire without prompting.

#Stage 12 — Capstone

Steady: week 12Committed: ≈ days 39–42Immersed: ≈ days 20–21

One small, real thing you want to exist — built the way you now work: planned, directed, verified, explained. Agent phase: delegate, with you as the engineer of record.

The last day: the retrospective. Read your whole log start to finish — the person who wrote Day 1 and the person reading it are different people. Then choose what's next.

#After the twelfth gate

You have habits, a portfolio repo, and an agent you know how to direct. Point it at something you love: a week-long game, web, app, or media track — immersed pace makes those a natural next month — or straight at the longer path toward working like an engineer. The daily log doesn't have to stop; only the schedule does.