The Developer's Video and Course Curation 2026 — Frontend Masters to YouTube, How to Learn by Watching

Prologue — When free, paid, and AI co-tutors meet on one screen

This post is the companion to The Developer's Bookshelf 2026, posted the same day. If books grow the skeleton of your judgment, video and courses are how you put muscle on it. And video in 2026 is not the same beast it was even three years ago.

Three things meet on one screen now:

• Free MOOCs got genuinely great. Harvard CS50, MIT 6.S081, fast.ai, and Hugging Face Learn deliver tier-one curriculum at zero cost.
• Paid boutique platforms evolved. Frontend Masters, Egghead, and Pluralsight are not schools — they're four-hour workshops from working engineers. The pulse of fast-moving tooling lives here, not in books.
• An AI co-tutor sits next to you. Video in one window, an LLM in the other. Pause anywhere and ask "why does this work that way." The shape of the learning curve has changed.

This post is a category-by-category map of that new screen. Platforms, channels, and talks — with three things for each:

• Killer feature — the one thing this place does better than anyone else
• Who it fits — junior, mid, or senior
• Price (as of 2026) — free, subscription, or per-series

The selection rule is simple: I include only what I've spent real time on, or what colleagues have recommended at least twice in the past year. "Famous" alone is not enough. At the end I list classic talks worth re-watching and a weekly learning routine that mixes video, books, and practice.

Video is a tool. Tools are put down when the job is done — they are not for showing off like a bookshelf. Your time is the most expensive thing here. Two well-chosen courses beat ten decent ones.

The platform matrix at a glance

These are 2026 standard rates. Check your company's learning budget first — 90% of the time the company pays.

1 · Boutique paid platforms — short and deep workshops

Frontend Masters

• Killer feature — 4 to 8-hour workshops taught by working engineers. Brian Holt (serverless/Vite/LLMs), Will Sentance (JS runtime, system design), Bekah HW (accessibility), Brian Lonsdorf (functional), Sunil Pai (React internals). Slides and repo links sit right next to the video.
• Who it fits — Frontend and full-stack devs, years 1–10. Especially mid-level engineers who need to absorb a new tool fast (TanStack Start, Solid Start, Bun full-stack).
• Price — 39 USD/mo, 390 USD/yr individual. Team licensing available. 7-day trial.
• How to use — Watch one workshop straight through at 1.5x. Type the code on your own machine. Don't rewatch — instead, apply the exercise to your own project once more.

Egghead.io

• Killer feature — Lessons are 3–7 minutes. "Why use this pattern" fits in 60 seconds. Series by Kent C. Dodds, Joel Hooks, and John Lindquist stand out. Subtitles and transcripts are first-class.
• Who it fits — People hunting for patterns. 30-minute evening or commute learners.
• Price — 25 USD/mo, 250 USD/yr individual. Some series free forever.
• Pitfall — Series depth varies. Pick by instructor, not by title.

Pluralsight

• Killer feature — The standard for IT certs and enterprise learning. AWS/Azure/GCP cert paths, security, and data curriculum are broad. Skill IQ measures your level.
• Who it fits — Cert seekers, and companies that buy bulk licenses for their teams.
• Price — 29 USD/mo, 299 USD/yr individual. Enterprise is where it lives.
• Pitfall — Tone is conservative, so trending tools land later than elsewhere. For new AWS services, vendor workshops are often faster.

Boot.dev

• Killer feature — A backend bootcamp built like a game. You write Go, Python, SQL, Docker, HTTP servers as you go. Auto-grading and explanations happen inside the CLI.
• Who it fits — First or second-year backend devs. Career switchers entering backend.
• Price — 34 USD/mo, 290 USD/yr. 7-day free.
• Pitfall — Almost no frontend. Pair with something else.

2 · University MOOCs — filling a CS bachelor's for free

Coursera

• Killer feature — Accredited university certs. Princeton Algorithms (Sedgewick), Stanford Machine Learning (original), and University of Michigan's Python for Everybody are still top-tier.
• Who it fits — People who need a credential they can put on a resume.
• Price — Audit free, cert 49–99 USD, Plus 399 USD/yr for unlimited access.
• Pitfall — Some courses haven't been refreshed in five years. Check the recording date.

edX

• Killer feature — Harvard CS50 (David Malan) is not a joke; it's the real thing. MIT 6.S081 (Operating Systems), MIT 18.06 (Linear Algebra by Strang), Berkeley CS61A together cover a CS undergrad first year.
• Who it fits — Self-taught and career-switching developers filling in CS gaps.
• Price — Audit free, verified certs 50–300 USD, MicroMasters 1500–4000 USD.
• Pitfall — Some courses have heavy auto-graders. If you don't need the cert, watch the lectures and substitute the assignments with code in your own codebase.

CS50 — Harvard's open course

• Killer feature — The gold standard for intro CS. Starts in C, moves to SQL, web, then Python. CS50P (Python), CS50W (Web), CS50AI (AI), CS50SQL form a series. The lectures are free on YouTube.
• Who it fits — Beginners, and anyone teaching beginners.
• Price — Completely free. The Harvard cert costs money on edX.

MIT 6.S081 — Operating Systems

• Killer feature — You modify the xv6 OS yourself. Implement page tables, syscalls, the filesystem with your own hands. Pairs perfectly with the OSTEP book.
• Who it fits — Backend and systems engineers building OS intuition.
• Price — Free (all materials public).

3 · ML/AI specialist courses — schools outside school

fast.ai

• Killer feature — Teaches top-down. Within the first hour you have a trained model running inference. Then you descend layer by layer until you hit gradients, optimizers, transformers. Jeremy Howard and Rachel Thomas's philosophy shows in every lecture.
• Who it fits — Developers who can code but are new to ML. Practitioners, not academics.
• Price — Completely free (videos, notebooks, book).
• Pitfall — Theory rigor (proofs, math) lives elsewhere. Pair with Goodfellow's Deep Learning or Stanford CS229.

Hugging Face Learn

• Killer feature — Separate courses for NLP, Diffusion, Reinforcement Learning, and Agents. Each comes with notebooks and Hub integration. The fastest-updating learning resource of 2024–2026.
• Who it fits — ML engineers actually shipping LLMs, transformers, and diffusion.
• Price — Completely free.

DeepLearning.AI

• Killer feature — Andrew Ng's lineup. New 1–2 hour short courses drop weekly. LangChain, MCP, multi-agent, evaluation — current LLM application topics ship fast. Full Specializations sit on top of Coursera.
• Who it fits — LLM application and MLOps starters. Tool-by-tool learning.
• Price — Most short courses free, Specializations bundled into Coursera subscription.
• Pitfall — Short courses are short. Depth needs supplementing.

Anthropic Academy / OpenAI Academy

• Killer feature — Official learning from the model companies themselves. Anthropic Academy covers Claude, MCP, tool use, and agents. OpenAI Academy covers GPT API, Agents SDK, and evals. First-class sources for the APIs you're actually using.
• Who it fits — Developers building agents and LLM applications.
• Price — Completely free.
• Pitfall — Vendor-centric. Pair with fast.ai and Hugging Face for comparative perspective.

4 · YouTube — free and fun channels worth following

YouTube has tone diversity. Tone matters because you watch only what you finish. I've grouped channels by domain.

4-1 · Frontend / full-stack

• Theo - t3.gg — TypeScript full-stack. Next.js, tRPC, Drizzle. Sharp but reasonable comparison videos. "Why I don't use this tool" content is his strength.
• Fireship — Famous for the 100-second video format. Compresses one tool's essence into 100 seconds. Shallow on depth but the best radar in the industry.
• Web Dev Simplified (Kyle Cook) — Friendly tutorials between intro and intermediate. JavaScript and CSS pattern videos shine.
• Lee Robinson — Vercel CEO. Channel from the person shaping Next.js, server components, and the cache mental model.
• Josh tried coding (Josh Goldberg) — Deep TypeScript content. Takes the type system seriously, inside out.

4-2 · Backend / systems / terminal

• ThePrimeagen (Michael Paulson) — Vim, terminal, systems programming, Rust, Go. His livestreams reading papers and blog posts together are a treasure. His keyboard videos are surprisingly serious too.
• Jon Gjengset — Rust livestreams. Two-plus-hour videos are normal. Live-codes data structures, concurrency, networking in Rust. Deep, no shortcuts.
• Ben Awad — Full-stack, interviews, live coding. Rust, Postgres, TypeScript.
• Hussein Nasser — Breaks DB and networking fundamentals into 100–200 video segments. TCP, HTTP, DB indexes done well.

4-3 · Data / ML / AI

• Andrej Karpathy — Neural Networks: Zero to Hero, GPT from scratch. Single videos run over two hours. Type along in a notebook and transformers and BPE tokenization become things in your hands.
• 3Blue1Brown — The mountain peak of math intuition video. Linear algebra, calculus, neural nets, and transformer visualization series.
• Yannic Kilcher — Paper reviews. 30–60 minutes each. Useful for getting the big picture before reading a paper.
• AI Explained — Model releases, benchmarks, news summary. Shows sources, not just headlines.
• Latent Space (swyx) — A podcast that also lives on YouTube. One-hour interviews with builders at model, infra, and tool companies.

4-4 · Engineering culture / system design

• Continuous Delivery (Dave Farley) — Thirty years of intuition on CD, testing, and architecture. The "why we keep making the same mistakes" series is his peak.
• ArjanCodes — Python design patterns, clean architecture. A rare serious teaching voice in the Python world.
• System Design Interview — Classic system design topics (URL shortener, news feed, messenger, booking system) one per video.
• ByteByteGo (Alex Xu) — System design infographics. Short and visual.

4-5 · Conference channels

• GOTO Conferences — Where Joe Armstrong, Rich Hickey, and Kevlin Henney's serious talks live. A treasury of re-watchable talks.
• Strange Loop (concluded 2023; archive permanent) — The peak of functional, distributed, language, and artistic computing for a decade. The archive is still there.
• JSConf / React Conf / Next.js Conf — A year's worth of JS ecosystem change in one sitting.
• Microsoft Reactor / Microsoft Developer — Official TypeScript, VS Code, Azure talks.
• ACM TechTalks — Turing Award lectures, classical academic content.

4-6 · Conversations and podcasts (with video)

• Lex Fridman Podcast — 3 to 5-hour long-form. Regular AI researchers, founders, physicists. Easy to fast-forward.
• Latent Space Podcast — Same channel as above; ML engineer and builder talk.
• Software Engineering Daily — Daily one-hour show. The broadest range.
• Bryan Cantrill talks — Not a dedicated channel, but his talks ("Fork Yeah! The Rise and Development of illumos", "Platform as a Reflection of Values") are on YouTube. First-class culture talks from a systems engineer.

5 · Talks worth re-watching (the classics)

Technology ages fast. Good talks don't. Here are the talks I come back to, ten years on.

• Rich Hickey — "Simple Made Easy" (Strange Loop 2011) — Pushes the distinction between simple and easy all the way. The starting point of the functional and Clojure camp, and equally of anyone trying to reason about complexity. One hour. Subtitles on.
• Rich Hickey — "Hammock Driven Development" — Don't think in front of code; think in a hammock. Reframes thinking from a tool problem to a posture problem.
• Joe Armstrong — "The Mess We're In" (Strange Loop 2014) — The Erlang creator's lament. Half-jokingly, fully seriously, on what CS has lost over fifty years.
• Bret Victor — "Inventing on Principle" (CUSEC 2012) — Immediate feedback, living tools. The origin point of every modern developer-tool design.
• Bret Victor — "The Future of Programming" (DBX 2013) — Dressed as a 1973 programmer, talks about the future. Once seen, you look at your own code differently.
• Alan Kay — "The Computer Revolution Hasn't Happened Yet" (OOPSLA 1997) — The OOP founder's self-critique on "misunderstood OOP."
• Bryan Cantrill — "Platform as a Reflection of Values: Joyent, Node.js, and beyond" — Systems, culture, and politics together. Dense as a talk gets.
• Kevlin Henney — "Seven Ineffective Coding Habits of Many Programmers" — Seven coding habit traps. After watching, your own code looks different.
• Sandi Metz — "All the Little Things" — Crystal-clear talk on object design. Starts in Ruby but language-agnostic.
• Greg Young — "8 Lines of Code" — Coupling, coupling, coupling hidden in eight lines. Domain modeling in earnest.
• Martin Kleppmann — "Turning the Database Inside Out" — DDIA's atmosphere compressed into one talk. The archetype of stream processing.
• Hadi Hariri — "It's Not About You — Designing for Users" — From JetBrains. User-centric design.

How to re-watch: once start-to-end, once with notes, then again a month later at 1.5x. Good talks only fully land on the third pass.

6 · A learning routine — video + book + practice

Watch video without writing code and 90% is gone in a week. Read books without practice and the same is true. Video, books, and practice have to roll together. This is what I actually do.

6-1 · Picking up a new tool (new framework, new DB, new language)

1. Fireship 100 seconds — Get the big picture.
2. One Frontend Masters or Egghead workshop (2–4 hours) — Build intuition from a serious course.
3. Official Getting Started — Type through it yourself.
4. Replace one slice of your own project with the new tool — Real learning starts here.
5. Ask an LLM co-tutor "why does this work that way" — Revisit what the video glossed over.
6. Write one blog post summarizing it — The gaps in your understanding surface as you write.

6-2 · Filling in a CS bachelor's

1. CS50 or CS61A — Pass through an intro once.
2. OSTEP + MIT 6.S081 — Operating systems.
3. CSAPP + Nand2Tetris (Coursera) — Computer systems and hardware.
4. Algorithms by Sedgewick (Coursera) — Data structures and algorithms.
5. DDIA + Strange Loop talks — Distributed systems.

There's no rush. Two or three months per course, two courses a year, five years for the bachelor's.

6-3 · ML and AI

1. fast.ai Part 1 — Make it tangible.
2. Karpathy's Zero to Hero — Build transformers and optimizers by hand.
3. Hugging Face NLP Course — Libraries and the Hub ecosystem.
4. DeepLearning.AI short courses — LangChain, MCP, evals, applications.
5. Anthropic Academy / OpenAI Academy — First-class source for the API you use.
6. fast.ai Part 2 or Stanford CS25 (Transformers United) — Next step.

6-4 · A weekly 24-hour learning budget (example)

• 30 min commute x 5 days (2.5 h) — Latent Space or Software Engineering Daily podcast.
• 20 min after lunch x 3 days (1 h) — Fireship 100 seconds, Theo live clips.
• 40 min evening x 4 days (2.5–3 h) — One workshop, one chapter per night.
• One 3-hour weekend block — One book chapter plus applying that chapter to your code.
• Remaining time (~15 h) — Work, exercise, sleep. Eight to ten hours of learning per week is enough. Push more and you won't last a year.

7 · Anti-patterns — what video can't do

• Mistaking watching for learning. The progress bar fills fast, fooling you. Without typing the code, almost nothing stays.
• New-tool chasing. A new framework video every week, but never finishing one tool. Cap new-tool learning at 20% of your time.
• Marathoning a 3-hour talk in one sitting. Only the first 30 minutes land. Break it up, take notes.
• Watching an English talk without subtitles. Turn them on. The gap between 90% and 60% comprehension is double the learning rate.
• Living on summaries only. Fireship 100 seconds is a radar tool. Don't confuse it with knowing the thing.
• Forgetting to cancel paid subs. Audit Frontend Masters, Egghead, Pluralsight quarterly. Drop them when idle; re-subscribe when needed.
• Outsourcing everything to AI. Pausing five times in a 30-minute video to ask the AI is learning. Asking the AI to summarize the whole video is not.

Epilogue — close the screen, return to code

The value of video and courses is in shortening the path from head to hand. A well-built four-hour workshop puts a tool in your hands without reading a book. But no course replaces a book. And no book replaces actually writing the code.

Learning in 2026 is layered: books for principles, video for tools, an AI co-tutor for the gaps, your own codebase for application. All four together is what makes a year's learning still be in your head a year later.

Checklist:

• Have you picked one workshop to finish this quarter?
• Have you canceled any paid subscription unused for 90 days?
• Have you re-watched one classic talk this month?
• Have you applied one chapter to your own code?
• Have you asked an LLM co-tutor three questions about something you just watched?
• At the end of the quarter, have you tidied the watched list and made the next quarter's queue?

Next post — The Developer's Conference Curation 2026. KubeCon, QCon, NeurIPS, SREcon, PyCon, React Conf. How to pick on/offline conferences, how to plan registration, travel, and visibility. Which talks to watch on video and which to attend in person.

References

Platforms

• Frontend Masters — https://frontendmasters.com/
• Egghead.io — https://egghead.io/
• Pluralsight — https://www.pluralsight.com/
• Coursera — https://www.coursera.org/
• edX — https://www.edx.org/
• Harvard CS50 — https://cs50.harvard.edu/
• MIT 6.S081 OS — https://pdos.csail.mit.edu/6.S081/
• MIT OCW — https://ocw.mit.edu/
• Berkeley CS61A — https://cs61a.org/
• fast.ai — https://www.fast.ai/
• Hugging Face Learn — https://huggingface.co/learn
• DeepLearning.AI — https://www.deeplearning.ai/
• Boot.dev — https://www.boot.dev/
• Anthropic Academy — https://www.anthropic.com/learn
• OpenAI Academy — https://academy.openai.com/

YouTube channels

• Fireship — https://www.youtube.com/@Fireship
• ThePrimeagen — https://www.youtube.com/@ThePrimeagen
• Theo - t3.gg — https://www.youtube.com/@t3dotgg
• Web Dev Simplified — https://www.youtube.com/@WebDevSimplified
• Lee Robinson — https://www.youtube.com/@leerob
• Andrej Karpathy — https://www.youtube.com/@AndrejKarpathy
• 3Blue1Brown — https://www.youtube.com/@3blue1brown
• Jon Gjengset — https://www.youtube.com/@jonhoo
• Hussein Nasser — https://www.youtube.com/@hnasr
• Continuous Delivery — https://www.youtube.com/@ContinuousDelivery
• ArjanCodes — https://www.youtube.com/@ArjanCodes
• ByteByteGo — https://www.youtube.com/@ByteByteGo
• Latent Space — https://www.youtube.com/@LatentSpaceTV
• Lex Fridman Podcast — https://www.youtube.com/@lexfridman
• Yannic Kilcher — https://www.youtube.com/@YannicKilcher
• AI Explained — https://www.youtube.com/@aiexplained-official

Conference channels

• GOTO Conferences — https://www.youtube.com/@GOTOConferences
• Strange Loop (archive) — https://www.youtube.com/@strangeloopconf
• JSConf — https://www.youtube.com/@jsconf
• React Conf — https://www.youtube.com/@reactjs
• Microsoft Reactor — https://www.youtube.com/@MicrosoftReactor
• ACM (Turing Lectures, etc.) — https://www.youtube.com/@AssociationForComputingMachinery

Talks worth re-watching — direct links

• Rich Hickey, "Simple Made Easy" — https://www.youtube.com/watch?v=LKtk3HCgTa8
• Rich Hickey, "Hammock Driven Development" — https://www.youtube.com/watch?v=f84n5oFoZBc
• Joe Armstrong, "The Mess We're In" — https://www.youtube.com/watch?v=lKXe3HUG2l4
• Bret Victor, "Inventing on Principle" — https://www.youtube.com/watch?v=PUv66718DII
• Bret Victor, "The Future of Programming" — https://www.youtube.com/watch?v=8pTEmbeENF4
• Alan Kay, "The Computer Revolution Hasn't Happened Yet" — https://www.youtube.com/watch?v=oKg1hTOQXoY
• Bryan Cantrill, "Platform as a Reflection of Values" — https://www.youtube.com/watch?v=9QMGAtxUlAc
• Kevlin Henney, "Seven Ineffective Coding Habits" — https://www.youtube.com/watch?v=ZsHMHukIlJY
• Sandi Metz, "All the Little Things" — https://www.youtube.com/watch?v=8bZh5LMaSmE
• Greg Young, "8 Lines of Code" — https://www.youtube.com/watch?v=lvxP6BVOZWQ
• Martin Kleppmann, "Turning the Database Inside Out" — https://www.youtube.com/watch?v=fU9hR3kiOK0

Companion posts in the same series

• The Developer's Bookshelf 2026 — Twelve CS Classics Worth (Re)Reading
• The Developer's Learning Complete Guide — New Language, Domain, Papers, Lifelong Learning, AI Partner
• The Engineer's Learning Engine — Books, Papers, YouTube, MOOC, Newsletter, AI Tutor, Zettelkasten