The 2026 course refresh — 28 lessons, all 8 tracks

A lot of what I teach on this site is stuff that doesn't change — the cascade, closures, recursion, Big-O, how to read a stack trace. Those lessons work the same in 2026 as they did in 2016.

But a chunk of the curriculum isn't like that. React 19.3 shipped a compiler. TypeScript 7 rewrote its compiler in Go. CSS got anchor positioning, container queries, and native nesting as baseline-available features. WCAG 2.2 added six success criteria most sites quietly fail. React Native made the New Architecture the default. Server Components and Server Actions stopped being a preview and became the shape of how most new rendered apps are built.

A course that mentioned none of this would have been quietly wrong. So I spent a while this autumn going through all eight tracks and adding what was missing. Twenty-eight new lessons later, here is what landed.

The shape of what I added

Each track got the specific pieces it was missing — nothing hand-waved, nothing invented. Grouped by track:

• React — four lessons: the React Compiler, <ViewTransition>, Fragment refs and Trusted Types, and routing with react-router v7.
• React Native — three lessons: the New Architecture as default (and what "bridgeless" actually means), the web-aligned event dispatcher, and React 19 running on native.
• TypeScript — three lessons: the native (Go-based) compiler, the two-step TS 6 → TS 7 upgrade path, and runtime validation at the API boundary with Zod, Valibot, and the Standard Schema interface.
• HTML & CSS — five lessons: WCAG 2.2's new success criteria, container queries, cascade layers, native CSS nesting, and anchor positioning.
• JavaScript — four lessons: AbortController and the stale-result race, testing with Vitest and MSW, service workers and offline, and the quiet distinction between the language's TC39 standards and the browser's host-provided APIs.
• System Design — five lessons: Server Components and Server Actions, cache invalidation across the stack, edge rendering's honest trade-offs, auth boundaries in a rendered app, and observability for a frontend.
• DSA for Frontend — two capstones: autocomplete as four stacked algorithms (prefix match, ranking, debounce, cancel), and the event loop treated as a scheduler you program against.
• Claude Code Masterclass — two lessons: a current-docs refresh on what's landed (forks, Workflow, Monitor, worktree isolation) and a worked agent-team exercise.

If you were in the middle of any of these courses, the new lessons are slotted next to the ones they're closest to — the React Compiler lands between useMemo/useCallback and keys-and-list-reconciliation, cascade layers lands right after the cascade-and-inheritance lesson, anchor positioning slots in after positioning. You won't have to hunt for them. The sidebar will show them in the order they belong.

The rule I tried to follow

Writing these, I tried to resist the "list every new feature" impulse. Novelty is not a reason to teach something. The question I asked before every lesson was: does this change what a reader needs to know, or does it just add a new way to do a thing they could already do?

If it changes the answer — if an existing lesson would now be wrong without it, or if a reader would quietly ship bad code because the course never mentioned it — the lesson is in. If it's the same job done a different way, I left it out.

That's why you won't see a lesson on every new CSS property shipped this year. You'll see cascade layers (changes how specificity actually works), nesting (changes what source files look like), anchor positioning (removes a whole category of JavaScript workaround), and container queries (changes what "responsive" means for a component). Not a lesson per property.

If you've been on the site a while

A few things are worth re-reading, not because the old lessons are wrong, but because the new lessons depend on them. If you want to get the most out of the refresh:

• In TypeScript, read the new "Validating at the API Boundary" lesson right after the existing one on async code. It's the piece that connects everything the track teaches to what actually happens when data crosses the wire.
• In System Design, read the new RSC lesson before the new edge-rendering and auth-boundary lessons. The three of them share a mental model.
• In JavaScript, read "Cancelling Requests" right after "Fetching Data" — they're genuinely one topic split across two lessons, now that modern cancellation is a real answer.
• In HTML & CSS, the WCAG 2.2 lesson is a short sit-down. Even if you don't work on a compliance-driven site, the six criteria are the right defaults for shipping something you don't regret.

If you've never been on the site, all of this is in the normal flow — you don't need to read anything in a particular order to get what you came for.

A quieter note

I didn't rewrite any existing lessons in this pass. The older material is still there and still correct for what it was teaching. The refresh is additive. Think of it as the course catching up with what the industry shipped this year, not an overhaul.

If you find a lesson that feels like it's missing something — a feature you were expecting, a pattern that's become standard, an honest caveat the old version didn't name — write to me. I'm doing this exercise more often than once a year now.

More soon.