The path

Day one. You wake up in front of a blinking cursor, learn to talk to the machine, and build your first folders and files without touching the mouse.

In the first session you learned to talk. Today you learn to see: where you are in the tree, what is around you, how to chain commands into combos, and why a file sometimes refuses you.

Three hours of work, one careless edit, everything gone. In a game that never happens, because you saved before the boss. Git is the save system for your code: snapshots you can return to, timelines you can try things in, and a merge that joins the best of both.

Everything you have built lives on one laptop. If the laptop dies, the work dies with it. Today the save system goes online: you prove who you are with a key, push your repositories to GitHub, open your first pull request, and ship the project every developer eventually builds, a dotfiles repo that can set up a new machine in one command.

Your dotfiles repo ships a seven-line setup script, and you can read every line of it. The full one has branches, a loop and a function, and you cannot read those yet. Today you learn the shell's sentence shapes one at a time, write down what each will print before you run it, and then assemble the script that sets up a new machine in one command.

Everything you have built so far is a black screen and white text. Today the work becomes something a person can see. A web page is a file a server sends because a browser asked, and HTML is the language that file is written in: a skeleton of named regions, not a programming language, and not a pile of boxes.

The skeleton from last session is sound, and it looks like a form from 1997. CSS is the armor: a separate file of rules that says which elements look like what. The work today is the system underneath the paint, because a rule that does not apply is almost never a mystery. It lost a fight you can learn to referee.

The armor is on, and everything is still one column. A navigation bar, a row of cards, a sidebar beside the story, a page that rearranges when the window gets narrow: that is layout. Flexbox handles one direction. Grid handles both. You write the small screen first, and each wider screen adds to it.

The page is structured, colored, and arranged, and it is still a still picture. A hover that eases, a card that lifts, a spinner that turns, a photograph that fits its frame: motion and fit are how a page tells you it can be touched. The names have to stay readable while you add them, which is what BEM is for.

Five sessions of skeleton, armor, formation and motion become one page with your name on it, and today it goes on the internet at a URL you can send to anyone. Then you prove the page a visitor gets is the page you built: on a phone, from the keyboard, with every path resolving under the prefix GitHub gives you.

Your first mana bar: where values live, the seven kinds they come in, and how a program picks a road.

Write the incantation once, name it, and cast it anywhere; then learn why some spells remember.

You can follow an example. Today you find out whether you can work without one: three dots, honest copies, the counting reduce, and three small problems on your own spellbook with no scaffolding and a worked answer only after you have tried.

One blueprint, five hundred knights, and the word that keeps losing its character.

Your JavaScript leaves the training dungeon: select a corner of the page, change it, and make it answer when someone clicks.

Project day. Everything from Unit 3 becomes one playable, deployed game with a URL you can hand to anyone.

JavaScript leaves the page. Node is the runtime that runs it on a machine, and Express is the small library that turns that machine into a server.

A request leaves your process and nothing comes back for a while. Today you learn what a promise is, how await waits on one, and how to tell a server that said no from a server that never answered.

One process, one port, and a stack of functions. Today you build the door: routes, middleware, and an error handler that actually answers.

A URL is not a page. It is a noun, the method is the verb, and the body is JSON. MVC is how you keep those three from collapsing into one file.

A variable dies when the process dies. A database is the other kind of memory: documents on disk, queried by fields, shared by every request.

MongoDB will store whatever you hand it. Mongoose is the keeper at the door: a schema, a model, validators, and queries that return promises.

Before React, the server sends the page. Seven routes, one resource, plain HTML and CSS. The name of the seven is INDUCES.

The same quests, with the HTML left behind. The client sends JSON and receives JSON. Status codes do the talking that a redirect used to do.

No React yet. A password becomes a hash, a login returns a signed token, and the next request carries that token in a header. The server is the only thing that believes it.

The page stops being a string you send once. React is a description of the UI from state. Change the state, and React updates the DOM.

State inside one component is not enough. Today the data lives above the children that need it, and effects are reserved for synchronizing with something outside React.

The pieces meet. A todo list in React, a JSON API in Express, a token from the login you already proved with curl. The screen waits for the server before it says saved.

You have built this shape once, with the notes open. Today you build it again, a spellbook instead of a todo list, and the notes stay closed until something actually breaks.

A spell has one owner. A party has many members, and a member stands in many parties. That second sentence is a different shape, and Mongoose will not invent it for you.

The unit's project. Accounts you already know how to seal, an inbox between them, and a pack of potions, weapons, and armor. Not every link is many-to-many. You have to say which is which.

Four units in, you have been casting at the model without an incantation. Today you learn one: Role, Task, Tone, Purpose, Output, Constraints, and a rubric that says whether the answer passed.

The six lines stay. Today you stack three techniques on them: examples from your own handlers, reasoning before writing, and prompts chained so one answer is the next one's context. The hall gets an unread count, built in the chat and verified with curl.

The model stops answering in a tab and starts editing files. Today you install one agent, give it a file of facts it reads before every task, put a branch under it, and let it make one scoped change to the hall that you review line by line and can revert completely.

The trial. Pick one feature of the hall you built by hand, write its acceptance cases down, delete it on a branch, and have the agent rebuild it to the same contract while a clock runs. The number you get is the number you get; the log is the evidence, and main gets the merge.

Everything you have built runs on your laptop. Today you rent a Linux machine in a data center, reach it with the key you already own, close every door but three, and leave it waiting for the guild hall.

Your server has an address and nothing answering it. Today Nginx takes the public door, a Node process waits behind it on a loopback port, and pm2 brings that process back after a crash and after a reboot.

Nobody will type your IP address. Today you register a name, point it at the droplet with one A record, and let certbot fetch a certificate so the browser shows a lock instead of a warning.

The server has a name, a lock, and a placeholder page. Today the guild hall moves in: a cloud database, a .env Node reads on the server, hall-api under pm2 on 4100, the Vite build behind Nginx, and a deploy script you can run again.

The guild hall is live and you have clicked through every screen. Nothing proves it except your memory. Today you write the first test that can fail, watch it fail on purpose, and learn why that red run is the whole point.

You proved the inbox by hand in 4-15 and wrote four statuses in a note. Today those four lines become four tests that send real requests through the real router into a database that exists only to be wiped.

Nobody uses the hall with curl. Sera uses the page. Today a browser you never touch logs in as Sera and reads Bran's letter, and then GitHub runs that same journey, and every Jest file, on a machine you will never see.

Green is not the same as safe. Today you list what would actually hurt a person using the hall, give each risk a test at the cheapest layer that can catch it, prove the suite from a clean clone, merge add-tests into main through a pull request, and write a report that says exactly what was and was not checked.

The guild hall is built. Nobody asked for it. Today you pick the capstone idea in one afternoon, open its repo, write seven questions that cannot be answered with a polite lie, and book the people who will answer them.

An idea sentence and one practice interview become a backlog: fifteen to twenty user stories, each tagged evidence or assumption, acceptance examples for the top five, a MoSCoW cut, RICE scores, and a board with four columns where the capstone will be built.

A board on the wall does not clear dungeons. Today every Must story gets a size, the backlog becomes the four sprints Unit 12 actually runs, Sprint 1 gets a goal that fits, and you run your first retrospective on the work you already did in Unit 7.

Three real people have talked to you. Today their words become a combined empathy map, a set of insights with counts instead of adjectives, a backlog revised line by line with a reason for every change, and the product spec that Unit 12 opens on its first morning.

JavaScript lets a typo ride all the way to production. Today you add a compiler that refuses, build a parser that turns unknown JSON into a type you can trust, and learn the two ways Node 24 runs a .ts file.

A lookup that takes a millisecond at a thousand rows takes six seconds at a hundred thousand. Today you measure that on your own machine, learn to say why, and build the three structures that make the shape of the growth a choice instead of a surprise.

A pattern is not a trick to memorize. It is what the structure of the input allows. Today you write the slow version first, keep it as the oracle, and let it prove that the fast version you wrote next gives the same answers.

Six problems you have not seen, one method you have. Today you take the best single trade from a restatement to a bench line, pause when the fast version agrees with the brute force on paper, and then run the same method five more times without the page holding your hand.

Your product spec says what the capstone does. Today you write the document that says how it will hold up: a workload you estimated, boxes you can defend, one request traced through them, one failure walked through, and one decision recorded with its reasons.

The guild hall works and has tests. Today you convert it to TypeScript in place, one boundary at a time, with the Unit 7 suite as the proof that nothing changed, and you record why the capstone will not get the same treatment.

The capstone gets its first line of code today, copied from the hall you already trust, and then it gets a barrier: every body validated into a shape you chose, headers Helmet sets for you, a limiter on the login door, and a process that refuses to start without its secrets.

The capstone takes its first payment today, in test mode, on a checkout page Stripe hosts. Your server picks the price, Stripe sends a signed event, and an order flips from pending to paid exactly once, no matter how many times the same event arrives.

The capstone gets its one AI feature today: a route that sends a bounded document to Claude from the server, streams the answer back over SSE, treats the document as data rather than orders, and reserves a slice of the user's daily token budget before it spends a single one.

Today the capstone goes live. You write the security audit with a piece of evidence beside every line, put a second limiter and an off switch on the AI routes, and deploy the API, the page, and a database to Railway so that from next session on the capstone is a URL and not a folder.

Your capstone is live and takes test payments. Before anyone hands you money, you decide whether you need it at all, and you model what a pre-sale leaves in the bank after fees, delivery, and refunds.

A noble offers gold for a share of the treasure. Today you read the post-money SAFE, run four conversion scenarios until the arithmetic is yours, and find the red flags in a one-page term sheet before you ever see a real one.

A venture fund's arithmetic decides what it can invest in before it ever sees your deck. Today you run that arithmetic, decide honestly whether your capstone fits, and start the twelve slides around the product you already deployed.

No new theory. You build the month-by-month cash model, let it overrule the slides it disagrees with, record the five-minute pitch against your live product, and score it yourself with the questions an investor would ask.

Your capstone already exists, already runs, and is already deployed. Sprint 1 is the day you stop guessing which Must-haves are finished and prove it, one slice at a time, against the plan you wrote in Unit 8.

The Must-haves agree with the plan. Sprint 2 builds the Should-haves that survived the cut and gives the core flow one status string that decides what every button does, so a double click, a failed save, and an empty list each do exactly one thing.

No new features today. Sprint 3 freezes one commit, runs the whole test tree against exactly that commit, attacks the ownership rules with a second account, restores a backup somewhere disposable, and redeploys with the path you already own.

The candidate is live. Sprint 4 hunts bugs as a stranger, gives every screen its loading, empty, and success sentences, adds the 404 page, writes a README someone can run from, and records the five-minute demo for the first time so you can watch it back before it counts.

At the end of the path, you record the demo that counts on the live URL, answer the five questions a reviewer would ask, score your own capstone against a hundred points, and hand the product to the person who will run it next: you.