Edit me, then hit Run

git commit -m "Fix typo in README install step"git push -u origin fix-typo-in-readme ``` 5. Open the pull request. Back on your fork on GitHub, click Contribute, then Open a pull request. Write a title and a short reason the change helps, and link the issue it closes ("Fixes #123"). 6. Answer review yourself. A maintainer will likely ask for a change. Push a follow-up commit to the same branch; it appears on the same pull request automatically. ## Why first pull requests get closed There's no single error message here, just a short list of habits that get PRs closed without a merge: - No issue, no claim. Opening a PR for unassigned or unrequested work duplicates someone else's effort or misses what the maintainer actually wants. - Ignoring CONTRIBUTING.md. Every project that has one wrote it because contributors kept getting the basics wrong. - Drive-by cosmetic changes. Reformatting a file you didn't otherwise touch adds review noise for no benefit. - Huge diffs from a first-time contributor. Small is reviewable; 40 changed files from someone with no history on the repo is not. - Undisclosed AI output. [ESLint's AI contribution policy](https://eslint.org/docs/latest/contribute/ai-policy) is a useful example of where this is heading across open source: "If you use AI to generate an issue or a pull request, you must clearly disclose this in your submission." Undisclosed AI-generated issues or PRs "may be closed without review," AI-generated PRs are only considered for issues the maintainers have explicitly marked `accepted`, and the policy is blunt about review: "Please do not feed maintainer comments back into an AI to generate responses." Maintainers expect a human on the other end of the conversation. The fix for all five is the same: pick a real, acknowledged issue, keep the change small, disclose any AI assistance, and understand every line you're submitting well enough to defend it in review. ## If you want to learn Git properly first If forking, branching and resolving a merge conflict felt new to you, not just new in this repo, [Learn Git and GitHub](https://scrimbaguide.tech/docs/courses/javascript/git-and-github/) is Scrimba's course for exactly that gap. From our review of the course: its Collaboration section walks through a two-account pull request, code review and merge conflict workflow, the same review and conflict-resolution skills you just used, and the first four scrims (about 14 minutes) are free before the rest moves to Pro. [Watch the free sample lessons](https://scrimba.com/learn-git-and-github-c0eh4kd7df?via=u42d4986) to see if the format fits before you commit to Pro. If the terminal itself is new territory, [Command Line Basics](https://scrimbaguide.tech/docs/courses/javascript/command-line-basics/) is worth doing first. ## Bottom line Hacktoberfest 2026 will not reward your pull request with a T-shirt for showing up four times. That's a fair trade. A pull request you open because it helps a real project, that you can explain line by line, is worth more to your GitHub history and to the maintainer reading it than ten rushed ones ever were. Do a practice run on first-contributions today, then find a real good-first-issue repo once October opens. If you want the in-person version, check [hacktoberfest.com/fests/](https://hacktoberfest.com/fests/) for one near you. Next step: open first-contributions right now and make the practice PR. It takes about ten minutes and it's the same workflow you'll use for real. ## Ready to start learning? Get full access to all Scrimba courses, paths, and community with Scrimba Pro. [Try Scrimba free](https://scrimba.com/?via=u42d4986) **Q: Does Hacktoberfest 2026 still count pull requests?** No. MLH and DEV announced on 2026-08-19 that pull requests are no longer counted. The event now centers on in-person Fests and an online program built around open source AI. **Q: Do I still get a T-shirt for Hacktoberfest 2026?** Only at in-person Fests, at the local organizer's discretion and while supplies last. Online participants are not eligible for a T-shirt; a Swag Envelope for online milestones ships 30 to 60 days after the event, with details still to come as of 2026-09-28. **Q: Who can take part in Hacktoberfest 2026?** Anyone 13 or older worldwide, subject to U.S. export controls and embargo restrictions. **Q: Can I use AI to write my first pull request?** Check the repository's own policy first; more projects are adopting rules like ESLint's, which requires disclosing AI use and only reviews AI-generated PRs against issues a maintainer has explicitly marked accepted. **Q: Where do I find beginner-friendly repos to contribute to?** GitHub's good-first-issue topic page lists thousands of repos filterable by language, or start with firstcontributions/first-contributions, a repo built specifically to be your first pull request. --- # How Long Does It Take to Learn Web Development in 2026? (Realistic Timeline) Source: https://scrimbaguide.tech/blog/how-long-to-learn-web-development-2026/ Most beginners need 120 to 150 hours of coursework and projects to reach job-ready frontend skills. At 10 hours a week, that is roughly 4 to 5 months including a job search. The hours split three ways: structured lessons, 30 to 50 hours of your own non-clone projects, and interview prep. Skip any of the three and the calendar math below stops working. ### How Long Will It Take to Learn Web Development? Anchored to Scrimba’s actual path hours. Adjust inputs to your situation. Your current levelComplete beginner (no coding experience)Know some HTML/CSSKnow basic JavaScriptTarget career pathFrontend Developer PathFullstack Developer PathBackend Developer PathAI Engineer PathHours per week: 10h5h10h15h20h25h30h3 months(12 weeks) estimated time to job-ready 82hpath content (8 weeks)+4 weeksportfolio projects + job prep[Start the Frontend Developer Path free →](https://scrimba.com/our-pricing?via=u42d4986&utm_source=scrimbaguide&utm_medium=calculator&utm_campaign=learning-time-calculator&utm_content=frontend)[See full path breakdown](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) Estimates based on Scrimba’s published path hours (Frontend: 81.6h, Fullstack: 108.4h) plus project time. Actual timeline depends on consistency, prior experience, and job-search effort. Individual results vary. Most people underestimate project time and job search time. Course hours are only half the story. ## How many hours does a frontend path actually take? I reviewed Scrimba's [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) inside the platform: 81.6 hours across 13 modules and 1,493 lessons, ending in a Getting Hired module of 73 scrims on portfolio, GitHub and interview drills. Add 40 hours of your own projects and you land at 122 hours of focused work, the point where you can build a React app and explain your choices in an interview. At 10 hours a week, 122 hours is 12 weeks of learning. Add 4 to 6 weeks for applications and interview rounds and a consistent learner lands near 4 to 5 months calendar time. Want backend and databases in the same track? The [Fullstack Developer Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) runs 108.4 hours across 20 modules, including Node, Express, SQL and a short AI engineering block. Scale the table below up by roughly a third if that is your target. ## Hours per week × what “done” means This table maps weekly intensity to three milestones: finishing a complete structured path, adding serious portfolio work, and a rough range to job-ready (learning + projects + a modest job search window). Figures assume a frontend-shaped roadmap (~122 hours learn + projects as above). | Hours / week | Complete path (~82h content) | With ~40h projects (~122h) | To job-ready (incl. ~4–8wk search) | | --- | --- | --- | --- | | 5 | ~16 weeks | ~24 weeks | ~7–9 months | | 10 | ~8 weeks | ~12 weeks | ~4–5 months | | 15 | ~5–6 weeks | ~8 weeks | ~3–4 months | | 20 | ~4 weeks | ~6 weeks | ~2.5–3.5 months | These are averages, not promises. Life happens. The table is useful for calendar planning, not for comparing yourself to strangers on Reddit. ## Why “course finished” ≠ “hireable” Employers source from a global applicant pool. [LinkedIn’s 2025 Future of Recruiting report](https://business.linkedin.com/talent-solutions/resources/future-of-recruiting) notes persistent demand for digital and technical skills and heavy use of skills-based signals, portfolios and assessments show up alongside degrees. Your GitHub, deployed demos, and how you explain trade-offs matter as much as whether you finished a checkbox list. That is why this guide bakes in 40+ project hours and a job search phase instead of stopping at “I watched React videos.” ## A realistic 2026 stack for juniors Most junior frontend job posts still orbit JavaScript, React, Git and increasingly TypeScript. The [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) matches that order: HTML and CSS basics, two JavaScript modules (9.6 and 10.6 hours) earlier in the 13-module path, then, several modules later, the 15.3-hour React basics module with Bob Ziroll and the 13.2-hour advanced React module. If you want backend exposure in the same subscription, compare [Scrimba Learning Paths](https://scrimbaguide.tech/docs/paths/). Here is that same stack as a stage budget, built from the path's own module durations, plus one course outside it: | Stage | Hours | Path module | Outcome | | --- | --- | --- | --- | | HTML + CSS | 6.3 hrs | Web dev basics | Static, responsive layouts without a framework | | JavaScript basics | 9.6 hrs | Making websites interactive | Variables, functions, DOM manipulation | | JavaScript patterns | 10.6 hrs | Essential JavaScript concepts | Closures and array methods React assumes you know | | React basics | 15.3 hrs | React basics | Components, props, state | | [Advanced React](https://scrimbaguide.tech/docs/courses/react/advanced-react/) | 13.2 hrs | [Advanced React](https://scrimbaguide.tech/docs/courses/react/advanced-react/) | Hooks, context, routing | | TypeScript | 4.2 hrs | [Learn TypeScript](https://scrimbaguide.tech/docs/courses/typescript/learn-typescript/) (separate course, not part of this path) | Interfaces, unions and generics at a beginner level | | Getting hired | 5.1 hrs | Getting hired | Portfolio, GitHub, LinkedIn, interview drills | That is 64.3 hours of guided lessons before your own projects (60.1 hours of it inside the [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) itself, plus the separate 4.2-hour [Learn TypeScript](https://scrimbaguide.tech/docs/courses/typescript/learn-typescript/) course), lower than the 81.6-hour path total above because it skips modules outside this core stack (accessibility, CSS grid patterns, APIs, code reviews). Add those back if a job post you are targeting names them specifically. Git runs in parallel with all seven stages, not after them: - Branch-per-feature on your own repos, one branch per piece of work. - Commits with imperative subject lines, kept small enough to review in a minute. - Pull requests even when you work solo, so the habit is already there when a reviewer is watching. The [Git and GitHub course](https://scrimbaguide.tech/docs/courses/javascript/git-and-github/) covers this in 1.7 hours across 40 lessons, short enough to fit into a single weekend alongside the stage above it. Once the stack is built, hiring managers scan for a short, specific list before they read a line of code: - A live URL sitting next to the repo link. - A README that explains decisions, not just install steps. - Commit history spread across weeks, not one heroic weekend. - One feature that is not in the tutorial you followed. For a week-by-week version of this same stack, see the [Frontend Roadmap 2026](https://scrimbaguide.tech/roadmaps/frontend-roadmap-2026/). ## Speed mistakes that add months - Skipping fundamentals, jumping to React before you can read JavaScript errors wastes time. - Only tutorial clones, recruiters have seen the same demo app hundreds of times. - No schedule, [Stack Overflow’s 2025 Developer Survey](https://survey.stackoverflow.co/2025/) shows most developers learn continuously; sporadic cramming rarely sticks. - Ignoring interview practice, coding under time pressure is a different skill than following a course. ## Part-time learners: protect the streak If you can only do five hours per week, you still finish, you just need calendar patience and brutal scope control. Pick one primary path ([Frontend](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) vs [Fullstack](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/)) and avoid parallel “I will also learn Rust this month” energy unless you truly have spare capacity. Micro-habits help: 25 minutes daily beats zero on busy weeks. Log hours in a notebook; humans overestimate “I studied a lot Sunday” and underestimate Tuesday’s skip. ## How to know a module is “done” “Done” is not “I watched it.” Done means you can rebuild the exercise tomorrow with the docs tab closed for at least the core logic. If you cannot, redo the capstone before advancing, otherwise timelines in the table above are fantasy. ## Backend or AI paths: different clocks The [Backend Developer Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/) and [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) target different job titles than classic frontend juniors. Hours and job-search windows still apply, but compare job posts in your city before you commit six months. ## Burnout and comparison Timelines from strangers skip childcare, night shifts and the weeks where nothing gets done. If your row in the table says eight weeks and your life says twenty, the table is an average and your week was not one of the averaged ones. ## Where Scrimba fits the timeline Scrimba's format has you typing code in the browser instead of watching it, which is closer to live coding under interview pressure than a video course is. The Frontend path publishes its hours module by module, so you can check your actual pace against the plan every week instead of guessing at month three. If you are ready to commit, one Pro subscription covers the path, the projects, and the interview-prep courses: [View Scrimba pricing and career paths](https://scrimba.com/our-pricing?via=u42d4986&utm_source=scrimbaguide&utm_medium=blog&utm_campaign=how-long-to-learn-web-development-2026&utm_content=inline) ## After you learn: getting hired Timeline articles stop early; hiring does not. When coursework and projects are in place, switch to execution mode: targeted applications, portfolio polish, and interview reps. Scrimba students should read [How to Get Hired Using Scrimba](https://scrimbaguide.tech/blog/how-to-get-first-developer-job-2026/). Anyone wanting a general playbook can follow [How to Get Your First Developer Job (2026)](https://scrimbaguide.tech/blog/how-to-get-first-developer-job-2026/). ## Bottom line How long does it take to learn web development? For many people, ~120–150 hours of focused learning and projects gets you to “can build and explain a React app.” Calendar months depend on weekly hours; 10 hours/week often means roughly 4–5 months including search. ## Frequently Asked Questions **Q: How long does it take to learn web development?** If you mean job-ready frontend skills, a structured path is roughly 80–120 hours of coursework plus 30–50 hours of portfolio projects. At 10 hours per week that is about 12–17 weeks of learning, plus typically 4–8 weeks of focused job search, often 4–6 months total for motivated beginners using a full-time-pace part-time schedule. **Q: How long to become a web developer in 2026?** In 2026, employers still expect HTML, CSS, JavaScript, a modern framework (usually React), Git, and 2–3 portfolio projects. With Scrimba’s Frontend Developer Path (~81.6 hours) plus ~40 hours of projects (~122 hours), 10 hours per week lands near three months of study before interviews. **Q: Can I learn web development while working full time?** Yes. Progress scales with weekly hours: 5 hours per week roughly doubles calendar time versus 10 hours per week. Consistency beats bursts, five focused hours weekly for a year beats quitting after an intense month. **Q: Do I need a bootcamp or degree to hit these timelines?** No. Self-paced platforms with structured paths can match bootcamp breadth if you complete solo projects and practice explaining your code. Degrees help for some employers; many junior roles prioritize GitHub and interview performance. **Q: What counts as job-ready?** Job-ready means you can build a small full frontend app from a written spec (routing, state, API calls, forms), debug without copying every line from a tutorial, and discuss your trade-offs in an interview, not that you have memorized every API. ## Plan your months, not just your weekends Structured paths, solo projects, and interview prep, learn at the hours-per-week you can sustain. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # Become an AI Engineer as a JavaScript Developer (2026) Source: https://scrimbaguide.tech/blog/how-to-become-ai-engineer-javascript-developer/ You can become an AI engineer as a JavaScript developer without learning Python first, as long as you are aiming at applied and integration roles rather than research or model training. The work that pays well in 2026, wiring language models, agents, retrieval, and the Model Context Protocol into real apps, runs on the JavaScript and TypeScript stack you already use. If you ship React or Node and you are tired of being told you need a year of Python and linear algebra before you can touch AI, that gate is mostly fictional for the jobs you would actually apply to. ## Can a JavaScript developer become an AI engineer without Python? Yes, if you are aiming at applied and integration roles. The AI engineering work that web companies hire for in 2026 is building features on top of models that already exist, and that work lives on the JavaScript and TypeScript stack. Python is the language of model research and training. It is not a prerequisite for putting a language model inside a product. Here is the opinion I will defend for the rest of this post: most "how to become an AI engineer" advice is Python-gatekeeping written by people who have never shipped an LLM feature. They tell you to spend a year on Python, NumPy, and the math behind backpropagation before you are allowed to begin. For a research-engineer role, that is fair. For the applied jobs that make up most of the openings, it is the wrong order, and it talks capable web developers out of a field they are already most of the way into. The line that matters runs between two kinds of work. Research and training roles build and improve the models. Applied and integration roles use them. If you can deploy a React app and authenticate against a REST API, you are closer to the second kind of job than to a junior frontend one. Python still matters on one side of that line, and the section below draws it exactly. ## What an AI engineer actually does (and why JavaScript covers most of it) An applied AI engineer builds product features on top of models they did not train. Day to day that means chat interfaces with streaming responses, retrieval over a company's own documents so the model answers from real data, agents that call external tools, and integrations that hand data to models in a standard way. It is integration and product work, much closer to full-stack web development than to data science. Look at what is missing from that list: training a model from scratch, designing a new architecture, tuning a loss function. Those are real jobs, and they are Python jobs, but they are a minority of what gets posted under the AI engineer title. The common case is a web product that needs an LLM feature shipped by someone who understands both the model API and the app it lives in. If you are worried AI is quietly eating the junior rung, I dug into [whether AI can replace junior developers](https://scrimbaguide.tech/blog/can-ai-replace-junior-developers-2026/), and the applied AI seat is one of the few entry points that is growing rather than thinning out. The skill is not exotic. It is web development with a model in the loop. ## Why 2026 is the year the JavaScript AI stack caught up The short reason is that the tools a JS developer needs to build with models now exist as first-class JavaScript libraries, not Python ports. Two years ago, building AI features in JavaScript meant fighting missing SDKs and half-finished ports at every step. That friction is gone as of 2025. Three things closed the gap. Anthropic open-sourced the Model Context Protocol in November 2024, and it became a cross-vendor standard through 2025 (OpenAI adopted it in March, Google in April), so there is now one way to connect tools and data to models instead of a different adapter per vendor. Vercel shipped AI SDK 5, its TypeScript AI toolkit, on July 31, 2025, and the Vercel AI SDK is now the standard way to stream model output into a React, Next, or Node interface. And OpenAI and Anthropic both ship official TypeScript SDKs, so calling a frontier model from JavaScript is a documented, supported path rather than a community workaround. The language data points the same direction. By GitHub's Octoverse 2025 (October 28, 2025), TypeScript is the most-used language on GitHub by contributor count, with Python second and JavaScript third (Python had overtaken JavaScript back in 2024). On Stack Overflow's separate 2025 survey, JavaScript was still the most-used language at 66% of all respondents, with Python at 57.9% of all respondents (54.8% of professional developers). Read together, those say one thing: the stack most web products ship in is JavaScript and TypeScript, and that is where AI features get built and deployed. If you have been weighing whether to commit to TypeScript, the AI tooling is one more reason it pays off, and I make the fuller case in [best TypeScript courses in 2026](https://scrimbaguide.tech/blog/best-typescript-courses/). ## The 2026 AI engineer job market, in real numbers Demand is real and the pay is high: LinkedIn ranked AI engineer the number one fastest-growing job in the US on its Jobs on the Rise list two years running, in both 2025 and 2026 (LinkedIn Jobs on the Rise, January 2026). The salary numbers below lean on self-reported data, which skews upward, so read them as a band rather than a floor. The demand is not confined to dedicated AI titles either: AI skills now show up in ordinary software job descriptions, leaking into roles that are not branded as AI jobs at all, a pattern our [junior developer job market 2026](https://scrimbaguide.tech/blog/junior-developer-job-market-2026/) breakdown tracks in Indeed's posting data. On compensation, Levels.fyi puts the median AI engineer total compensation near $154,000 as of mid-2026, with the broader ML/AI software-engineer category around $243,000, and frontier labs far above that. Their data is self-reported and leans toward higher-paying employers, so treat it as a band, not a floor. PwC's 2026 Global AI Jobs Barometer found a 62% wage premium for workers with AI skills, up from 57% a year earlier. For how those numbers sit against general developer pay, I keep [the developer specialization job market guide](https://scrimbaguide.tech/blog/developer-specialization-job-market-2026/) with the wider bands. The figure to internalize is the premium rather than any single salary. The same web developer skills, plus the ability to ship AI features, command measurably more, and the gap is widening year over year. ## What you already know that transfers, and the three gaps to close Most of an applied AI engineer's toolkit is web development you already do. Async code and promises, calling and authenticating against APIs, parsing JSON, building interfaces, and deploying to a real host all carry over unchanged. An LLM endpoint is, mechanically, just another API that returns text. What you probably have not done falls into three gaps. The first is treating a model as a reliable function: prompting it so it returns structured, parseable output every time, not prose you have to scrape. The second is retrieval: embedding your own data, storing the vectors, and querying them at request time so the model answers from your documents instead of guessing. The third is agency: giving a model a set of tools, running the loop that lets it choose which to call, and handling the failures that loop produces. Close those three and you have the core of the job. The rest is ordinary web work. ## Your JavaScript-first AI engineer roadmap, skill by skill Build one small thing at each stage instead of collecting tutorials. The order matters, because each skill assumes the one before it. - Call a model and get structured output. Use the official OpenAI or Anthropic TypeScript SDK to send a prompt and get back JSON your code can trust. Until the output is parseable every time, nothing downstream is reliable, so this is where to spend your first week. - Stream the response into a UI. Wire the model into a React or Node interface with the Vercel AI SDK so tokens appear as they generate. This is ordinary client and server work pointed at a model endpoint, and it is the part you will find easiest. - Add retrieval, also called RAG. Embed your own documents, store the vectors in a database, and query them per request so the model answers from your data. It is data plumbing with one new concept, embeddings. Scrimba's [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) course builds exactly this in 22 scrims, ending in a similarity-search project against Supabase. - Build a tool-using agent. Give the model functions it can call, run the loop where it picks one, and handle the retries and dead ends. This is the moment an LLM stops generating text and starts taking actions. Scrimba's [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) course builds a ReAct agent by hand across nine parts and 31 scrims before adding an OpenAI functions agent on top. - Standardize tool access with MCP. Expose your tools and data through the Model Context Protocol so any compatible model can reach them without custom glue per integration. Scrimba's [Intro to MCP](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/) course covers servers, tools, resources, transports, and trust boundaries in 17 scrims. - Deploy and manage context. Ship to a live URL, control what you send the model each step to keep cost and reliability sane, and add simple checks so you catch wrong output before a user does. Keeping it dependable once real traffic hits it is what actually pays, and that work outlasts any single model. Assembling this yourself works, and plenty of disciplined developers do it. It costs hours of sequencing instead of money. The pre-ordered version of this exact list is at the end of this post. ## When you actually need Python You need Python when the job is to build or change models, not use them. Research-engineer roles at frontier labs, fine-tuning and training pipelines, novel architecture work, and most ML-heavy data teams assume Python, the math under it, and tools like PyTorch. Interviews at those companies test things a short applied course never covers, and no amount of JavaScript substitutes for that. There is also a softer version. Even in applied work you will occasionally hit a task, a data-processing script, a notebook a colleague shares, an evaluation harness, where Python is the path of least resistance. That is fine. Picking up enough Python to read and run a script is a weekend, and it is a different thing from "learn Python first before you are allowed to start." Defer it until a real task asks for it. So the rule is short. Applied and integration roles: JavaScript is enough to get hired and to do the work. Research and training roles: learn Python properly and budget months. Pick your target before you pick your reading list. ## The portfolio that gets a JavaScript AI engineer hired What gets you the interview is a small set of working projects, not a certificate. Employers on the applied side want to see you ship the three gaps as real apps, so a good starter portfolio is three projects, each deployed to a live URL. Build a retrieval app over documents you actually have, your notes, a codebase, a product manual, anything where the model answering from your data clearly beats it guessing. Build a tool-using agent that calls at least one real external API and handles that call failing without crashing. Build something that exposes a tool through MCP, so you can speak to the standard now reshaping how models reach data. Then write a paragraph on each project about where it broke and what you fixed. That failure write-up is what separates someone who followed a tutorial from someone who understands the system. For the broader principle that shipped projects beat credentials, see [the portfolio projects that get you hired](https://scrimbaguide.tech/blog/portfolio-projects-get-hired-2026/). ## Self-assemble vs the structured version of what you just built by hand You can assemble all of this for free, and plenty of disciplined people do. The official SDK docs, Vercel's AI SDK guides, the MCP specification, and the free intro material from the model vendors cover every skill on the roadmap. The cost is paid in hours rather than money: the time you spend sequencing it yourself, hitting dead ends, and never quite knowing whether the order you chose is the order that matters. A structured path trades a low monthly subscription for that sequencing. Scrimba's [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) runs 11.4 hours across nine modules, JavaScript and TypeScript throughout, no PyTorch. Per Borgen leads the path, Tom Chant teaches the [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) module, and Arsala Khan teaches Open-Source Models and Context Engineering. It wires LLMs, agents, RAG, and MCP into apps you already ship, in roughly the order this roadmap lists, which is the order a real project gets built in. The free intro lessons let you test the edit-the-instructor's-code format before paying anything (current [Scrimba pricing](https://scrimbaguide.tech/docs/pricing/), and what is free, are spelled out there). For the module-by-module breakdown, including what it skips, I keep a full review of the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/). If you want the exact course order to follow, [Scrimba's AI courses](https://scrimbaguide.tech/docs/courses/ai/) and the [complete AI Engineer Path guide](https://scrimbaguide.tech/blog/scrimba-ai-engineer-path-guide/) go course by course. This post is the why and the roadmap. Those two are the what and the how. If you are still weighing that path against other options, [the best AI engineering courses of 2026](https://scrimbaguide.tech/blog/best-ai-engineering-courses/) lines it up against the alternatives. Either way, the action this week is the same. Pick one project from the list above, the retrieval app is the easiest place to start, and get it answering from your own documents by Sunday. You will learn more from one shipped feature than from another month of deciding whether you are allowed to begin. ## Frequently asked questions Can a JavaScript developer become an AI engineer without learning Python first? Yes, for applied and integration roles. The jobs that involve wiring LLMs, agents, retrieval, and the Model Context Protocol into real products run on the JavaScript and TypeScript stack, and the official OpenAI and Anthropic SDKs plus the Vercel AI SDK cover that work without Python. Research and model-training roles are the exception and still expect Python. When do AI engineers actually need Python? When the job involves training, fine-tuning, or interpreting models rather than calling them. Research-engineer roles at frontier labs, ML-heavy data teams, and most academic work assume Python, the math behind it, and tools like PyTorch. If your target is shipping AI features in web apps, you can defer Python until a specific task asks for it. What does an applied AI engineer build day to day? Features on top of existing models: chat interfaces with streaming responses, retrieval over a company's own documents, agents that call external tools, and integrations that expose data to models through MCP. It is integration and product work, closer to full-stack web development than to data science. How much do AI engineers make in 2026? Levels.fyi puts the median AI engineer total compensation near $154,000 as of mid-2026, with the broader ML/AI software-engineer category around $243,000 and frontier labs far above that. Those self-reported numbers lean toward higher-paying employers, so treat them as a band, not a floor. PwC's 2026 Global AI Jobs Barometer also found a 62% wage premium for workers with AI skills, up from 57% a year earlier. What is the fastest JavaScript-first route into AI engineering? Learn to call an LLM API and get structured output, stream it into a UI, add retrieval with embeddings and a vector store, build a tool-using agent, then standardize tool access with MCP. Build one small project at each stage instead of collecting tutorials. That sequence maps to applied AI work and skips the model-training material you would not use. Is AI engineer just a rebranded web developer role? Not quite, but the overlap is large for applied roles. You reuse your knowledge of async code, APIs, JSON, and deployment, then add three things you probably have not done: prompting models for reliable structured output, retrieval, and agent loops with tool calling. A web developer who closes those gaps is closer to an applied AI job than to a fresh frontend hire. ## A JavaScript-first AI path No Python detour. Learn agents, RAG, and MCP in JavaScript on Scrimba's AI Engineer path. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # How to build your first AI agent in 2026 (no Python) Source: https://scrimbaguide.tech/blog/how-to-build-ai-agent-beginners-2026/ To build your first AI agent, you hand a language model one tool it can call and a loop that lets it decide when to call it. That is the whole idea, and you can do it in JavaScript in an afternoon without touching Python. If you are a web developer who keeps landing on "AI agent" tutorials that open with a Python virtual environment and a model-training detour, this is the shorter route: one keyless API, about forty lines of code, and a plain explanation of the two terms the rest of the internet is being strange about, MCP and context engineering. ## The short version: an agent is an LLM that can take actions An AI agent is a language model that can take actions between your question and its answer, instead of only producing text. That is the entire distinction, and it is worth getting it from a primary source rather than a vendor landing page. Anthropic's definition is the clean one: agents are "systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks" (Building effective agents, December 2024), as opposed to workflows, where the code path is fixed in advance. In practice the difference comes down to a loop. A single prompt is one input and one reply. An agent gets a request, decides whether it needs a tool, calls that tool, reads what came back, and then decides what to do next, possibly calling another tool before it answers you. You wrote the tools and the stop condition. The model chose the order. That choosing is the part people mean when they say "agentic." This is not a fringe interest anymore. Gartner named multiagent systems, collections of interacting AI agents, one of its top strategic technology trends for 2026 when it published the list in October 2025. On the hiring side, LinkedIn's Jobs on the Rise 2026 (January 2026) ranked AI Engineer the number one fastest-growing job in the US, and levels.fyi puts applied AI engineer total compensation in roughly the $134k to $193k band at mainstream employers as of mid-2026, with frontier labs pulling the top of the range far above that. The skill is real and it pays. The barrier to a first version is much lower than the job titles suggest. ## What is MCP (Model Context Protocol), in plain terms MCP is a shared standard for telling a model what tools and data it can use, so you write an integration once instead of rewriting it for every model. The closest familiar comparison is HTTP: every browser speaks it, so any browser can load any website without a custom integration per site. MCP aims to be that for tools, so an agent built against one model can reach the same tools when you swap to another. The timeline is what makes it worth your attention rather than a passing acronym. Anthropic introduced the Model Context Protocol and open-sourced it on November 25, 2024, as an open standard for connecting models to tools and data. In March 2025 OpenAI adopted MCP, with Sam Altman saying support would roll out across OpenAI's products. Google followed in April 2025, with DeepMind CEO Demis Hassabis confirming Gemini would support MCP. Within about five months of launch, MCP had backing from all three major model vendors, which almost never happens that fast with a new standard. You do not need MCP for your first agent. The build below uses one inline tool, defined right in your own code, and that is the right place to start. MCP earns its keep later, when you want the same tool reused across different models or exposed to other people's agents without rewriting the glue each time. I reviewed Scrimba's [Intro to Model Context Protocol course](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/) scrim by scrim with a Pro account: Maham Codes teaches it in 17 scrims over about 37 minutes, and you build a weather MCP server in Node.js and TypeScript with one tool, one resource, and a STDIO transport, the exact step past the inline tool below. ## What context engineering actually means Context engineering is deciding what information and tools to put in front of the model at each step of a task. I will say the slightly cynical thing first: as a named discipline it is partly a rebrand of something developers were already doing, which is choosing what goes in the context window and when. The term got popular in 2025. The underlying problem is older than the label. That said, the problem it points at is real, and two of the companies pushing the term define it usefully. LangChain's working definition is "building dynamic systems to provide the right information and tools in the right format such that the LLM can plausibly accomplish the task" (The rise of context engineering, June 2025). Anthropic frames it as "the set of strategies for curating and maintaining the optimal set of tokens (information) during LLM inference" (Effective context engineering for AI agents, September 2025), which is a fancier name for the old question of what you put in the context window and when. The reason it matters more for agents than for plain prompts is the loop. A prompt is one input you write once and tune by hand. An agent accumulates context as it runs: your question, the tool calls, every result those calls returned, and its own intermediate reasoning. By the tenth step the window can be full of stale tool output that crowds out the thing the model needs to answer well. Scrimba's [Learn Context Engineering course](https://scrimbaguide.tech/docs/courses/ai/context-engineering/), reviewed here in full, is built around exactly that token-budget problem: Arsala Khan's one-hour course over 15 scrims has you add a system prompt to one chat app, then trim old messages by token count, then replace them with an AI-written summary once the app starts forgetting. ## What you need before you build your first agent You need three things: Node 20 or newer, an API key from one model provider, and the ability to call a fetch. That is genuinely the whole list. For the toolkit, I used the Vercel AI SDK, which Vercel describes as "the leading TypeScript toolkit for building AI applications" and reported at over 20 million monthly downloads in its AI SDK 6 announcement (December 2025). It handles the loop, tool calling, and streaming so you are not hand-rolling the request format. The example here was tested with the `ai` package on its current major version (v7) on Node 20, in late June 2026. Version 6, released December 22, 2025, is where MCP support became stable if you go that route later; the plain-tool code below works the same on either. The data source is the part where I can keep the "no API key friction" promise honestly. Open-Meteo needs no API key and no sign-up for non-commercial use, so the worked example is a plain fetch with nothing to configure. You still need one key for the model itself (OpenAI or Anthropic, your call), but the tool the agent calls has nothing to register, no billing dashboard, and no rate-limit page to read first. That is usually the step where beginners stall, and here it is gone. ## Build your first AI agent: a worked example Here is a working weather agent in about forty lines. It answers a question like "should I bring an umbrella in Berlin tomorrow?" by calling a real forecast API and reasoning over the result, instead of guessing from training data. Install the dependencies first: ``` npm init -ynpm install ai @ai-sdk/openai zod ``` Set `"type": "module"` in your `package.json`, export your `OPENAI_API_KEY`, then create `agent.js`: ``` import { generateText, tool, stepCountIs } from 'ai';import { openai } from '@ai-sdk/openai';import { z } from 'zod';const getWeather = tool({ description: 'Get the chance of rain tomorrow for a city', inputSchema: z.object({ city: z.string() }), execute: async ({ city }) => { const geo = await fetch( 'https://geocoding-api.open-meteo.com/v1/search?count=1&name=' + encodeURIComponent(city), ).then((r) => r.json()); const { latitude, longitude } = geo.results[0]; const data = await fetch( 'https://api.open-meteo.com/v1/forecast?forecast_days=2' + '&daily=precipitation_probability_max' + '&latitude=' + latitude + '&longitude=' + longitude, ).then((r) => r.json()); return { city, rainChanceTomorrow: data.daily.precipitation_probability_max[1] }; },});const result = await generateText({ model: openai('gpt-4o-mini'), tools: { getWeather }, stopWhen: stepCountIs(5), prompt: 'Should I bring an umbrella in Berlin tomorrow?',});console.log(result.text); ``` Run it with `node agent.js`. The model reads your question, sees it has a `getWeather` tool, calls it with `city: "Berlin"`, the function hits Open-Meteo and returns a rain percentage, and the model writes an answer grounded in that number. The one line that makes this an agent rather than a single call is `stopWhen: stepCountIs(5)`. Without it, the model answers once from whatever it already knows. With it, the SDK runs the loop: call the tool, feed the result back, let the model decide whether it is done or needs to act again, up to five steps. That loop is Anthropic's "dynamically direct their own processes" definition, written out in code you can read. Swap the weather function for any API you already call at work, and the shape does not change. ## Context engineering for agents that don't fall over A toy agent works on the first question and starts to wobble on the tenth, and context engineering is the set of fixes for that wobble. The failure modes are predictable once you have built one. The model forgets something it was told early because newer tool output pushed it out of the window. It calls the same tool twice because it lost track of the first result. On a bad day it loops, burning tokens and your API budget, because nothing told it when to stop. The fixes map directly onto the definitions above. Cap the steps, which the example already does with `stepCountIs`. Trim or summarize old turns before they crowd out the current task, instead of replaying the entire history every step. Pass the model only the tools a given step needs, not all twenty you eventually build, because a long tool list is its own kind of noise. None of this is exotic. It is bookkeeping about what the model sees at each step, which is the whole job that the "context engineering" label points at. The agents that stay reliable in production are the ones where someone did this bookkeeping deliberately. ## From toy agent to a structured build Once you have felt where the toy version strains, the forgetting, the runaway loops, the pain of wiring each new tool by hand, the next move is to learn the upgrades in the order a real project needs them: retrieval so the agent can pull from your own documents, MCP so tools are reusable instead of hard-wired, and a deploy so it runs somewhere other than your terminal. That is the gap a guided sequence closes. Scrimba's [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) runs about 11.4 hours across nine modules, taught entirely in JavaScript and TypeScript (no PyTorch): you build a ReAct agent by hand, run retrieval over your own data, and deploy a Node app to Render, with MCP and Context Engineering added as their own modules recently. I broke down the full module list and who it suits in the [AI Engineer Path review](https://scrimbaguide.tech/blog/scrimba-ai-engineer-path-guide/), and there is a free intro scrim with Tom Chant so you can test the edit-the-code format before paying anything. If it clicks, Pro is a low monthly subscription (see current [Scrimba pricing](https://scrimbaguide.tech/docs/pricing/)). I point you there for one reason: the path teaches MCP and context engineering as the named answers to the exact failures your forty-line agent just hit, in roughly the sequence a real build follows. For the deeper why-JavaScript argument, [Scrimba's AI courses](https://scrimbaguide.tech/docs/courses/ai/) covers the same ground from the curriculum side. ## Common beginner mistakes when building AI agents The mistakes are predictable, and most cost you a day each if you do not see them coming. The first is reaching for MCP or a heavyweight framework before a single inline tool works. Get one `fetch`-backed tool returning real data first; standardize and reuse it later. The second is shipping without a step cap, which is how a loop quietly runs your API bill up while you watch the terminal. The third is trusting tool output and model reasoning without reading either, the same almost-right trap that bites people pasting AI-written code: an agent that calls the wrong endpoint and confidently summarizes the wrong number looks exactly like one that worked. The fourth is starting in Python because a tutorial told you that is where AI lives. It is true that 84% of developers now use or plan to use AI tools (Stack Overflow 2025 Developer Survey, the freshest published numbers), and plenty of them are JavaScript developers wiring agents into apps they already ship. If you can call an API, you are closer to this than the Python-first framing suggests. For a sense of which assistants actually help while you build, I keep [a rundown of AI tools every developer should know](https://scrimbaguide.tech/blog/ai-tools-every-developer-should-know-2026/). So here is the concrete next step, and you can finish it today. Build the weather agent above, confirm it actually calls Open-Meteo, then change one thing: swap the weather function for an API you already use in your own work, a database lookup, an internal endpoint, anything that returns data the model cannot guess. When the model calls your tool and answers from the result, you have built an agent. Everything after that is making it reliable. ## Frequently asked questions How do I build my first AI agent in 2026? Give a language model one tool it can call, such as a function that fetches data, and a loop that lets it decide when to call that tool. The model reads your request, calls the tool, reads the result, and answers. In JavaScript with the Vercel AI SDK this is about forty lines of code, and you can finish a working agent in an afternoon. What is MCP, the Model Context Protocol, in plain terms? MCP is a shared standard for telling a model what tools and data it is allowed to use, so you write an integration once instead of once per model. Anthropic introduced it on November 25, 2024, and within about five months OpenAI and Google had both adopted it, which is why it is worth learning once your agent needs more than one tool. Do I need to learn Python to build an AI agent? No. If you can call an API with fetch in JavaScript, you can build a real agent. Python dominates model training and research, but the agents shipped inside web apps are mostly JavaScript and TypeScript, supported by the Vercel AI SDK and the official OpenAI and Anthropic JS clients. You only need Python if you move into training or research roles. What does context engineering actually mean? Context engineering is deciding what information and tools to put in front of the model at each step of a multi-step task. A prompt is one input you write once. Context engineering manages the whole evolving context across the loop: what stays, what gets trimmed, and what the model still sees on the tenth turn rather than only the first. What is the difference between an AI agent and a single prompt? A single prompt sends one input and gets one answer back. An agent can take actions between the question and the answer. Anthropic defines agents as systems where the model directs its own steps and tool use, as opposed to workflows where the code path is fixed in advance. The loop that lets the model decide its next step is what makes it an agent. How long does it take to learn to build AI agents? A first working agent takes an afternoon. Getting reliable agents that handle retrieval, multiple tools, and deployment takes longer. Scrimba's [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) covers that ground in 11.4 hours of interactive lessons, taught in JavaScript and TypeScript, which is a realistic estimate for the full on-ramp rather than the toy version. ## Go past the toy agent Scrimba's AI Engineer path sequences agents, RAG, and MCP so your second agent holds up. Start free. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # Reading Code: The Skill AI Coders Skip in 2026 Source: https://scrimbaguide.tech/blog/how-to-get-better-at-reading-code-2026/ The fastest way to get better at reading code is to read more of it on purpose: small pieces, out loud, predicting what each line does before you run it. AI writes the first draft now, so your job is verifying it, which makes reading the highest-leverage skill a self-taught developer can build in 2026. Most beginners still drill the half of the job the machine already does and skip the half interviewers now test. I learned to code through 42 Network, a project-based school with no lectures, so this is written from the same seat as the readers who skip roadmaps and build. ## The skill nobody put on their 2026 roadmap Reading code is the skill that jumped from "nice to have" to "the actual job" and almost nobody added it to their learning plan. Every beginner roadmap still optimizes for writing syntax from a blank file. But when a tool drafts that syntax for you, the bottleneck moves to understanding, checking, and correcting what it produced. The industry noticed before the roadmaps did. A 2026 daily.dev analysis of how junior developers should adapt argues the junior skill set has shifted from writing syntax to reading code, debugging steadily, and weighing trade-offs, which is precisely the work AI tends to skip. If you have been grinding "build a to-do app" tutorials and wondering why you still freeze in front of unfamiliar code, this is why. You practiced production. The market rewards comprehension. ## Why reading code got harder the moment AI started writing it Reading got harder because AI-generated code looks confident and correct even when it is subtly wrong, which is the most expensive kind of wrong to catch. Human-written bugs often look like mistakes. AI bugs look like finished work. The Stack Overflow 2025 Developer Survey, released in July 2025, puts numbers on the strain. AI adoption climbed to 84% of developers, yet trust in accuracy fell: 46% now distrust AI output, up from 31% the year before, and experienced developers are the most skeptical of all. The single biggest frustration, named by 66%, is code that is almost right but not quite. Another 45% say debugging AI-generated code takes them longer than writing it themselves. Almost-right is the trap. It compiles, it runs, it survives a five-second glance, and the defect surfaces weeks later. There is also a quieter cost to leaning on the tool while you are still learning. Anthropic's January 2026 study, a randomized trial of 52 junior engineers learning the Python `trio` library, found the group with AI access scored 50% on a follow-up comprehension quiz versus 67% for those who wrote the code by hand, a gap of nearly two letter grades. Debugging skills declined the most. The nuance worth keeping: developers who used AI to passively generate code scored below 40%, while those who used it to ask questions and probe trade-offs scored 65% or higher. The tool is not the problem. Reading nothing and shipping everything is. ## Reading code is really three skills, not one Reading code well means doing three separate things, and beginners usually only attempt the first. Naming them lets you practice the ones you are weakest at instead of rereading the same file and hoping. The first is tracing execution: following control flow line by line and holding each variable's state in your head, so you can say what the code actually does. The second is reconstructing intent: inferring what the author or the model was trying to accomplish, which lets you tell a deliberate choice from an accident. The third is spotting the gap: comparing what the code does against what it should do, where bugs, missing edge cases, and security holes live. Writing exercises all three at once and hides which is weak. Reading isolates them, so when you get stuck, notice which of the three failed. That is your training target. ## How to practice reading code as a beginner without a giant codebase You do not need a huge repository to practice reading; you need short, unfamiliar snippets and a habit of predicting before you run. The goal is reps on comprehension, not exposure to scale. A few methods that work with almost no setup. Take any small function you did not write, cover the body, and predict the output from the signature and a sample input before you reveal it. Read one open-source pull request a day on GitHub and try to explain, in a sentence, what each changed file is for before reading the description. Retype a snippet by hand instead of pasting it, which forces your eyes across every token. And use the tool you already have: paste code into ChatGPT and ask it to quiz you on what a specific line does rather than to explain the whole thing, so you answer first and check second. This is the same discipline I argue for in [learning to code with AI without depending on it](https://scrimbaguide.tech/blog/how-to-learn-coding-without-depending-on-ai/), applied to reading instead of writing. The rule underneath all of it: never let your eyes slide past a line you could not explain to someone else. ## A line-by-line checklist for reviewing AI-generated code When AI hands you code, read it against a fixed checklist rather than trusting that it ran. Reviewing is now a core skill precisely because generation is cheap and verification is not: a 2026 VentureBeat report on one industry survey found 43% of AI-generated code changes still needed manual debugging in production, even after passing QA and staging. Run each block through these questions, in order: - What is this supposed to do? State the intent in one sentence before you judge the code. If you cannot, you are reviewing syntax, not behavior. - Does the control flow actually reach every branch? Trace the paths. AI loves to write handling for a case that the logic above it makes unreachable. - What are the edge cases? Empty arrays, null, zero, the very large input, the concurrent call. Almost-right code usually handles the happy path and nothing else. - Where does the data come from, and is it trusted? Unvalidated input, missing auth checks, and secrets in the wrong place are the errors that survive a quick read. - Does it invent an API? Confirm that every method and import exists. Models hallucinate plausible function names that do not. - Can I delete anything? Extra abstraction you cannot justify is a smell, not sophistication. This is not busywork; it is the exact task some 2026 hiring screens now use. One widely shared screening guide for hiring engineers who use AI recommends handing candidates a roughly 50-line AI-generated snippet and asking them to explain it line by line, testing reading over recall. If you can run that checklist out loud, you can pass that interview. ## Interactive lessons make you read code instead of watch it The format you learn in decides whether you build the reading muscle or the watching one. Passive video trains recognition, which feels like understanding and collapses the moment you face code you did not just watch someone type. This is where an interactive format has a structural edge. When you learn by editing the instructor's code directly in the browser and running it, you cannot skim; you have to read the existing lines well enough to change them and see what breaks. That is reading practice disguised as a lesson, which is why I keep pointing beginners toward hands-on platforms over long lecture playlists (I compare the trade-offs in [best interactive coding platforms for 2026](https://scrimbaguide.tech/blog/best-interactive-coding-platforms-2026/) and in [Scrimba versus learning to code with ChatGPT](https://scrimbaguide.tech/blog/scrimba-vs-chatgpt-learn-to-code/)). Scrimba is built on exactly this loop, and [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) is the clearest example: module 4 alone is 2.7 hours and 55 scrims building a blackjack game, and nearly every one of those scrims stops mid-recording and hands you the editor before it shows the solution. You cannot pass that module by watching. It is free, so testing whether editing-in-place suits how you read costs nothing. If it clicks, the [frontend developer path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) runs the same loop across 1,493 scrims and 13 modules, MDN-endorsed, ending in a portfolio and a 73-scrim interview-prep module. Not sure where you'd fit? Try the [path finder](https://scrimbaguide.tech/tools/which-scrimba-path/) first. Current [pricing is here](https://scrimbaguide.tech/docs/pricing/) if you want to compare the subscription against a bootcamp. ## Where reading practice falls short Reading fluency does not replace writing fluency. You still have to build things from scratch to internalize how the pieces connect, and a reader who never ships is just a slower critic. If you have already slid into pasting AI output you cannot explain, this article is prevention, and the repair is a different job I walk through in [how to learn coding without depending on AI](https://scrimbaguide.tech/blog/how-to-learn-coding-without-depending-on-ai/). Reading small snippets also will not teach you to navigate a large unfamiliar codebase; that is its own skill, built only on real projects. And the research behind this piece is early: Anthropic's January 2026 trial covered 52 people learning one library, and the Stack Overflow figures are self-reported. Read them as a strong signal, not settled proof. The direction is consistent across every source anyway: generation keeps getting cheaper, and verification keeps getting more valuable. ## Your 30-day plan to build the reading muscle Spend 30 days making reading a daily rep, and by the end you will trace unfamiliar code without panic. Keep it small and consistent; ten focused minutes beats a weekend binge you never repeat. Week 1: predict before you run. Take one short function a day you did not write, guess its output from the signature, then run it and diff your guess against reality. Week 2: add the review checklist. Have AI generate one small function daily and review it against the six questions above before you accept a line. Week 3: read one open-source pull request a day and write a one-sentence summary of each changed file before reading the author's description. Week 4: reverse the interview. Grab a 50-line snippet you have never seen and explain it out loud, line by line, as if a hiring manager were listening, because soon one will be. [JavaScript Interview Challenges](https://scrimbaguide.tech/docs/courses/javascript/javascript-interview-challenges/) is built for exactly this rep: Treasure Porth hands you 28 short problems and stops before every solution, so you talk through your reasoning first the same way you would in a real interview. ## Why reading code is your edge in an AI-saturated job market Reading code is your edge because it is the skill the AI-first beginner is quietly skipping, which makes it scarce exactly as it becomes essential. When most candidates can generate a working function and few can vet one, the person who reads well is the safer hire. The signals line up. Screens test comprehension over recall. Experienced developers, per the Stack Overflow 2025 survey, trust AI output least, so judgment is now the senior skill. And the failure mode everyone is fighting, code that is almost right, is only ever caught by a human who read closely enough. Writing got commoditized; reading did not. Build the muscle nobody else is training and you stop competing with the tool and start being the reason it can be trusted. ## References - [How AI assistance impacts the formation of coding skills](https://www.anthropic.com/research/AI-assistance-coding-skills) - Anthropic's January 2026 randomized trial on comprehension and debugging when learning with AI. - [Stack Overflow's 2025 Developer Survey results](https://stackoverflow.co/company/press/archive/stack-overflow-2025-developer-survey/) - 84% AI adoption alongside distrust rising to 46% from 31%. - [AI section, 2025 Stack Overflow Developer Survey](https://survey.stackoverflow.co/2025/ai/) - 66% frustrated by almost-right code, 45% find debugging AI code slower than writing. - [43% of AI-generated code changes need debugging in production](https://venturebeat.com/technology/43-of-ai-generated-code-changes-need-debugging-in-production-survey-finds) - verification burden persists past QA and staging. - [How to hire engineers who use AI in 2026](https://www.kore1.com/hire-engineers-who-use-ai/) - screening that asks candidates to explain an AI-generated snippet line by line. - [How junior developers should adapt to AI in 2026](https://daily.dev/blog/how-junior-developers-adapt-to-ai/) - the junior skill set shifting from writing to reading and reviewing. **Q: How do I get better at reading code as a beginner?** Read short, unfamiliar snippets every day and predict what each line does before you run it. Cover a function's body, guess its output from the signature and a sample input, then check. Reading one open-source pull request a day and summarizing each changed file builds the same muscle without needing a large codebase. **Q: Why is reading code suddenly so important in 2026?** Because AI writes the first draft now, so your job shifts from producing code to verifying it. The Stack Overflow 2025 Developer Survey found 84% of developers use AI while 66% get burned by output that is almost right but not quite. Catching that requires reading closely, which is why hiring screens increasingly test comprehension over recall. **Q: How do I review AI-generated code line by line?** State what the code is supposed to do in one sentence, then trace the control flow, hunt the edge cases, check that inputs are validated, and confirm every API it calls actually exists. A 2026 VentureBeat report found 43% of AI code changes still needed manual debugging in production, so treat generated code as a draft to verify, never a finished answer. **Q: Does using AI to code make you worse at reading it?** It can, if you passively accept output you never study. Anthropic's January 2026 trial found developers who used AI to just generate code scored below 40% on a comprehension quiz, while those who asked questions and probed trade-offs scored 65% or higher. How you use the tool decides whether your reading skill grows or atrophies. **Q: What is the best way to practice reading code?** Practice where you cannot skim. Editing real code in an interactive lesson forces you to read existing lines well enough to change them, unlike watching a video. Pair that with a daily habit: predict outputs before running, retype snippets by hand instead of pasting, and refuse to keep any line you cannot explain out loud. ## Practice reading code, not just watching it Scrimba makes you edit the instructor's code in the browser, so you have to read every line before you can change it. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # How to Get Coding Experience Without a Job (2026) Source: https://scrimbaguide.tech/blog/how-to-get-coding-experience-without-a-job-2026/ You build coding experience without a job by manufacturing the proof a job would have given you: shipped projects real people use, open source contributions with your name on the merge, small freelance or volunteer work, and public build logs that show how you think. In 2026 that is not a clever workaround. It is the main road, because the entry-level rung that used to hand beginners their first experience has largely collapsed. I learned to code through the 42 Network rather than a CS degree or a bootcamp, so I built every hour of my early experience without an employer, and the tactics below are the ones that actually move a resume from ignored to interview. ## The experience paradox: why 'entry-level' now wants 3+ years "Entry-level" has quietly stopped meaning "no experience required." In an August 2025 analysis of more than 2,000 job posts labeled entry-level, The Interview Guys found that across all sectors only about 65% were truly open to zero experience, with the rest wanting prior experience. In software and IT the squeeze is worse: over 60% of those entry-level roles actually demand 3+ years. Some asked for up to five years while still calling the role a starting job. That is the catch-22 in one sentence: you need experience to get the job that would have given you experience. The gap between "I can code" and "I have been paid to code" becomes the whole obstacle. The good news is that the obstacle is made of evidence, and evidence is something you can produce on your own. ## What the 2026 hiring data actually shows The data shows a broken on-ramp, not broken demand. The Stanford ADP-payroll study (Brynjolfsson et al., "Canaries in the Coal Mine") found that software-developer employment for workers aged 22 to 25 has fallen nearly 20% since late 2022, while developers 30 and older at the same firms saw employment grow by roughly 6 to 12%. The squeeze is landing on the youngest, least-experienced tier. The same study, reported by CNBC in August 2025, found entry-level employment in AI-exposed occupations (software among them) dropped about 13% since 2022. But zoom out and the demand is intact: the US Bureau of Labor Statistics still projects about 15% growth for software developers from 2024 to 2034, and one 2026 market analysis (Final Round AI) describes a market that is splitting rather than shrinking, with senior demand persisting while junior postings sit below their 2022 peak. The floor fell out of the first job, not the career. I wrote up the fuller picture in [the junior developer job market in 2026](https://scrimbaguide.tech/blog/junior-developer-job-market-2026/). ## Why AI deleted the tasks juniors used to learn on Juniors used to earn experience by doing the small, well-defined work nobody senior wanted: bug fixes, boilerplate, unit tests, glue code. AI now does most of that in seconds, which quietly removed the training wheels the old ladder ran on. The first rung got automated before you could stand on it. This does not mean coding skill matters less. It means the skill that counts has shifted. The Stack Overflow 2025 Developer Survey, released in July 2025, found 84% of developers now use or plan to use AI tools, yet the single biggest frustration, cited by 66%, is AI output that is "almost right, but not quite," and trust in AI accuracy is falling. Anthropic's January 2026 study, "How AI assistance impacts the formation of coding skills," points the same way: AI-assisted learners scored markedly lower on a comprehension quiz, and the durable edge is being able to read and reason about code, catching the plausible-but-wrong answer, rather than typing code from scratch. So the experience worth building is judgment: shipping software that works and knowing when the machine is confidently wrong. I go deeper on that in [how to learn coding without depending on AI](https://scrimbaguide.tech/blog/how-to-learn-coding-without-depending-on-ai/). ## Reframe: experience is proof you can ship, not a job title Reframe experience as evidence, not employment. A hiring manager does not literally need you to have held a job; they need confidence that you can ship working software, read a codebase you did not write, and not take down production. Anything that produces that confidence reads as experience, payroll or not. A deployed app with real users, a merged pull request in a tool a team depends on, a paying freelance client with a testimonial: each answers the only question the employer is really asking. A 2026 DEV.to writeup by practitioner Charlie Morrison makes the tactical version of this point: drop the "junior" label, route around AI-filtered job boards through communities, and lead your resume with production-level work instead of tutorial clones. You are not lying about a title. You are showing the thing the title was supposed to guarantee. ## Seven ways to build real coding experience without a job Here are seven ways to build legitimate experience, ordered roughly from lowest to highest barrier. The goal of each is the same: produce something a stranger could verify. Do two or three well rather than all seven shallowly. - Ship real, deployed projects that solve a real problem. Not another tutorial to-do app. Solve something you or someone you know actually has, put it online, and write the README a reviewer would read. See [portfolio projects that get you hired](https://scrimbaguide.tech/blog/portfolio-projects-get-hired-2026/) for what "real" looks like. - Contribute to open source. Start with documentation fixes and small bug fixes on a tool you already use. A merged PR in a real repository is experience with your name permanently attached. - Freelance small gigs. A landing page for a local business, a bug fix on Upwork, a scraper for someone in a niche community. Small, paid, and real beats big and imaginary. - Do pro bono work for nonprofits. Charities and community groups need websites and small tools and will happily give you a reference and a live URL in exchange. - Build in public. Post weekly build logs on LinkedIn or a blog: what you built, what broke, how you fixed it. This turns invisible practice into a visible track record. - Reproduce production-grade engineering. Add tests, continuous integration, deployment, and error monitoring to a project. Doing the unglamorous parts is exactly the experience employers doubt you have, and [how to learn DevOps](https://scrimbaguide.tech/blog/how-to-learn-devops-2026/) covers that layer in order. - Reverse-engineer a real product. Rebuild a feature from an app you admire and document the trade-offs. It shows you can read and reason about non-trivial systems. Most of these pair naturally with a structured curriculum. If you are still filling core gaps, the [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) gives you something concrete to build against: 13 modules and 1,493 scrims that end in a Getting hired module covering portfolio, GitHub, LinkedIn and interview drills, so the projects you ship for this list and the path's own capstones can be the same projects. ## Open source, freelance, and apprenticeships: the back doors that still open Three of those channels convert to actual offers more often than the rest, because each hands you something a solo project cannot: a reference, income proof, or a formal foot in the door. Open source is the highest-trust signal you can earn for free. Skip the "good first issue" gold rush on famous repos and go deep on a smaller library you use. Fix its docs, then its tests, then a real bug. Maintainers remember people who show up twice, and a maintainer's recommendation outweighs any certificate. Freelance and contract work gives you the one thing portfolios lack: someone who paid you and will say so. Nonprofits, local businesses, and small creators are the realistic starting market. The catch is that solo work has no code review, so treat every gig as a chance to practice the professional wrapper (version control, a clean handoff, a written scope), not just the code. Apprenticeships and contract-to-hire are the formal back doors, and they still open. Programs that hire on aptitude and a short project rather than years of history exist specifically to solve the paradox in this post. They pay less up front, but they convert a stranger's doubt into a start date, which is the whole game. ## What self-built experience can't do It won't match a real job title on paper, and it won't happen in a weekend. Self-built experience competes at a disadvantage against candidates who held actual jobs, it takes months of consistent output, and a minority of employers (regulated industries, some large firms) still filter hard on titles and degrees you cannot manufacture. There are failure modes to name. Open source can burn you out chasing merges that never land. Freelance work without code review can cement habits a real team would have corrected. Portfolio projects tend to converge on the same ideas, so a tenth weather app impresses no one. And the 2026 market is genuinely tough at the bottom, so treat everything here as raising your odds, not removing the wait. Build the experience and apply broadly at the same time; the application mechanics (resume, ATS keywords, interviews) I covered in [how to get your first developer job](https://scrimbaguide.tech/blog/how-to-get-first-developer-job-2026/). ## Your 90-day plan to look experienced enough to get hired Ninety days is enough to go from "no experience" to "demonstrably employable" if you spend it producing evidence instead of consuming tutorials. - Days 1 to 30: Pick one stack and build one real, deployed project end to end. Not a clone. Solve a small genuine problem and write a README a hiring manager would actually read. - Days 31 to 60: Ship a second, different project and land one real-world commitment: a merged open source PR, a pro bono site for a nonprofit, or one tiny paid gig. - Days 61 to 90: Add production polish (tests, CI, deployment, one bug you debugged in public), publish two build logs, and start applying with your production-level work leading the resume. The one variable that decides whether this works is consistency, and consistency is mostly about how you learn. I built my early experience by writing and breaking real code, not by watching it, which is why I rate project-based learning over passive video. Scrimba's format has you editing and running real code from the first minute, and its free courses let you build shippable projects without paying anything to see if the style fits. The [6-month study plan](https://scrimbaguide.tech/docs/paths/study-plan/) breaks that path into 10 to 15 hrs/week milestones, and the [Path Advisor](https://scrimbaguide.tech/tools/which-scrimba-path/) picks your lane in about a minute; if the format clicks, Scrimba Pro is a monthly subscription (see current [pricing](https://scrimbaguide.tech/docs/pricing/)). Either way, the plan is the same: pick one track, ship one real thing this week, and put it somewhere a stranger can click it. ## References - [The Interview Guys: We Analyzed 2,000 'Entry-Level' Job Posts](https://blog.theinterviewguys.com/we-analyzed-2000-entry-level-job-posts/) - over 60% of entry-level software roles demand 3+ years - [CNBC on Stanford's ADP-payroll study](https://www.cnbc.com/2025/08/28/generative-ai-reshapes-us-job-market-stanford-study-shows-entry-level-young-workers.html) - entry-level AI-exposed employment down 13% since 2022 - [Stanford ADP-payroll study, additional coverage (TechJack Solutions)](https://techjacksolutions.com/ai-brief/stanford-ai-index-2026-developer-employment-for-workers-unde/) - the same research: developer employment for workers under 25 down nearly 20%, developers 30+ up 6 to 12% - [Final Round AI: Software Engineering Job Market 2026](https://www.finalroundai.com/blog/software-engineering-job-market-2026) - ~15% growth from 2024 to 2034 and a splitting, not shrinking, market - [US Bureau of Labor Statistics: Software Developers, Occupational Outlook Handbook](https://www.bls.gov/ooh/computer-and-information-technology/software-developers.htm) - about 15% growth from 2024 to 2034 - [DEV.to: How to Actually Get Hired as a Junior Dev in 2026](https://dev.to/charliemorrison/how-to-actually-get-hired-as-a-junior-dev-in-2026-when-nobody-is-hiring-juniors-1ehh) - lead with production-level work, drop the junior label - [Stack Overflow 2025 Developer Survey](https://survey.stackoverflow.co/2025/) - 84% AI adoption, top frustration is code that is almost right - [Anthropic: How AI assistance impacts the formation of coding skills](https://www.anthropic.com/news/AI-assistance-coding-skills) - AI-assisted learners scored markedly lower on a comprehension quiz **Q: Can you get a coding job with no experience in 2026?** Yes, but not by applying blind. Because most 'entry-level' postings now expect 3+ years, you have to arrive with substitute experience: deployed projects, merged open source work, or a paid gig. Those convince a hiring manager you can ship, which is the thing the missing job title was supposed to prove. **Q: How do I get coding experience without a job?** Produce verifiable proof of work. Ship two or three real, deployed projects, contribute small fixes to open source tools you use, take on a tiny freelance or pro bono gig, and post build logs publicly. Each item is something a stranger can click and check, which reads as genuine experience on a resume. **Q: Do open source contributions count as real experience?** Yes, and they carry unusual weight. A merged pull request in a real repository shows you can read an unfamiliar codebase, follow a team's conventions, and get code reviewed and accepted. Start with documentation and small bug fixes on a smaller library you already use rather than chasing famous projects. **Q: Is freelancing a good way to build developer experience?** It is one of the strongest, because it gives you a paying client and a reference, which portfolios cannot. The risk is that solo work has no code review, so bad habits can set in. Treat each gig as practice for the professional wrapper too: version control, clean scope, and a tidy handoff. **Q: How long does it take to build enough experience to get hired?** Plan on several months of consistent output, not a single weekend. A focused 90-day sprint can produce two deployed projects plus one real-world commitment like a merged PR or a small gig, which is usually enough to start applying with production-level work leading your resume. Keep applying while you build. ## Build experience by building real projects Scrimba's free courses let you ship real, hands-on projects and test the interactive format before you pay anything. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # How to Get Your First Developer Job in 2026 (General Guide) Source: https://scrimbaguide.tech/blog/how-to-get-first-developer-job-2026/ Getting your first developer job is the process of turning learn-to-code effort into hireable proof: shipped projects, a resume machines can parse, interview skills under time pressure, and a network that knows you exist. It is not one heroic weekend, it is repeated small bets over weeks and months until a team says yes. This guide is general, useful no matter which courses you used. Pair it with role-specific reading at the end. ## ATS: your resume is parsed before it is read Most applications hit an Applicant Tracking System first. Recruiters routinely manage hundreds of applicants per role; software filters on keywords, titles, and sometimes formatting before a human scrolls your GitHub. That is not cynicism, it is logistics. Your job is to pass the parser without lying. ### Job title keywords must match exactly If the posting says “React Developer” and your resume only says “Frontend Engineer”, you may still pass, but if the req lists React, TypeScript, JavaScript, and Git, mirror those exact tokens in a Skills line and in project bullets where true. | Keyword gap | What goes wrong | | --- | --- | | You write “JS” only | Some parsers do not synonym-map to JavaScript | | You omit TypeScript | You look like a JavaScript-only candidate for a typed codebase | | You say “APIs” but not REST | You miss a common filter phrase | | No GitHub URL above the fold | Humans never reach your best evidence | ### Honest mirroring beats keyword stuffing Copy-paste the requirements section into a private doc. Highlight phrases you genuinely satisfy. weave them into impact bullets: “Built a React dashboard with TypeScript that consumes REST endpoints, GitHub: …” ## Table: employer archetypes (what they optimize for) | Employer type | Skills emphasis | Degree often required? | Portfolio weight | Interview style | | --- | --- | --- | --- | --- | | Startups | Ship fast, tolerate ambiguity, sometimes design sense | Less often | Very high | Practical conversation, small take-homes | | Agencies | Deadlines, maintainable code, CMS or component libraries | Rarely for juniors | High | Portfolio walkthrough, client-style questions | | Mid-size product | Team rituals, code review, incremental delivery | Sometimes | High | Structured panels, live coding | | Big tech / FAANG-style | Algorithms, scale, sometimes deep frontend systems | More often | Medium-high with a high bar | Multiple rounds, bar raisers | Use this as a compass, not a law. Always read the exact team’s post and glassdoor-ish signals. ## Step mindset: projects are the universal currency Three non-tutorial projects beat thirty forks of the same bootcamp assignment. Project A, depth: extend something you understand; add auth, tests, or accessibility. Project B, breadth: new domain (dashboard, widget, small SaaS) with a different data model. Project C, polish: README with architecture sketch, trade-offs, and “if I had two more weeks.” For more ideas. See [portfolio projects that get you hired](https://scrimbaguide.tech/blog/portfolio-projects-get-hired-2026/). ## GitHub: curate, do not hoard - Pin two or three repos. - README: problem, stack, setup, screenshots, live link. - Commits: readable messages; squash only if you understand rebasing. - Issues/PRs if you pair, signals collaboration. If you have experiments, move them to a second account or an `archive/` org, first impressions matter. ## LinkedIn: SEO for humans and bots - Headline: role + stack + proof (“React · TypeScript · shipped analytics UI”). - Featured: live demos and one repo deep-link. - About: short paragraphs, background, stack, two shipped outcomes, what you want next. - Open to work: realistic locations and remote stance. Recruiters search “React AND TypeScript AND junior”. Give them the string. ## Applications: sustainable pipeline 5–10 tailored applications weekly beats 200 identical clicks. Track a spreadsheet: | Field | Purpose | | --- | --- | | Company + role URL | Avoid duplicates | | Stack tags | Reuse tailored bullets | | Referral | Warm intros change odds | | Stage + date | Psychology and follow-ups | Quality means: one paragraph why this product, one project hyperlink that matches their stack, and a headline that echoes their title language. ## Technical interview prep (junior-realistic) - JavaScript: closures, promises, array methods, truthiness, still the spine of most web screens ([Stack Overflow Developer Survey 2025](https://survey.stackoverflow.co/2025/) shows JS ubiquity). - React: hooks rules, derived state mistakes, effect cleanup. - Take-homes: time-box, README, and do not deploy secrets. Practice out loud. Record yourself explaining a repo for ninety seconds, painful and useful. ## Networking without the cringe - Comment with specifics on posts in your stack. - Ship in public weekly, screenshots beat manifestos. - Informational chats, ask how their team interviews juniors, not “please hire me” as the opener. ## Market context Entry-level hiring has friction in 2026. See [Junior Developer Job Market 2026](https://scrimbaguide.tech/blog/junior-developer-job-market-2026/) for the macro picture. Friction does not mean stop; it means differentiate harder with README depth and interview reps. ## Optional: structured learning while you search A subscription will not get you hired, but it keeps the reps consistent, and Scrimba's career paths end with a job-search module instead of just a certificate. The [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) closes its 13 modules with a 5.1-hour Getting Hired block, 73 scrims where Bob Ziroll covers portfolio building, LinkedIn, resume keywords, and salary talk. The [Fullstack Developer Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) runs the same closing act as Launching Your Career, 5.3 hours that add JavaScript, React, and frontend interview-challenge drills on top of the LinkedIn and resume work. Both sit behind the same Pro plan; the [pricing page](https://scrimbaguide.tech/docs/pricing/) covers what it costs: [Browse Scrimba career paths](https://scrimba.com/our-pricing?via=u42d4986&utm_source=scrimbaguide&utm_medium=blog&utm_campaign=how-to-get-first-developer-job-2026&utm_content=inline) ## Timeline cross-link Learning hours and calendar months interact. See [how long to learn web development](https://scrimbaguide.tech/blog/how-long-to-learn-web-development-2026/) for a calculator-backed plan. ## Closing How to get hired as a developer in 2026 is portfolio + keywords + reps + network, repeated until one team converts. There is no secret handshake, only visible proof and consistent volume with feedback loops. ## Frequently Asked Questions **Q: How do you get your first developer job in 2026?** Build three non-tutorial portfolio projects, polish GitHub and LinkedIn, tailor resumes with ATS-friendly keywords, apply to 5–10 well-researched roles per week, practice technical and behavioral interviews, and network consistently. Execution over months beats one perfect weekend. **Q: How many jobs should a junior developer apply to per week?** Aim for roughly 5–10 quality applications weekly, customized resumes or cover notes, correct titles, and links to relevant projects. Mass applying with identical resumes often yields worse conversion than fewer targeted applications. **Q: What is ATS and why does it matter?** Applicant Tracking Systems parse resumes before humans see them. If your headline and skills section omit exact phrases from the job post (for example React and TypeScript), you can be filtered out even with strong projects. **Q: Do I need a degree to get hired?** Not for every employer. Many teams hire on portfolio and interviews. Some large companies or regulated industries still prefer degrees. See our [developer job without degree guide](https://scrimbaguide.tech/blog/developer-job-without-degree-2026/) for data and nuance. **Q: Is this guide only for Scrimba students?** No, this playbook works regardless of which courses you used. Scrimba students get a built-in shortcut: the Frontend and Fullstack paths both close with a dedicated hiring module (5.1 and 5.3 hours) instead of ending at the last lesson, but every step here applies to self-taught and bootcamp learners too. ## Stack proof, then stack offers Use structured learning if it keeps you consistent, then let your GitHub do the talking. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # How to learn to code with AI without getting dependent on it Source: https://scrimbaguide.tech/blog/how-to-learn-coding-without-depending-on-ai/ The way to learn coding without becoming dependent on AI is to make the tool explain, never letting it produce. Set that as your default and dependency never gets a foothold, because the skill you would otherwise hand to the tool stays in your own hands. This is a prevention guide for the beginner who can already ship something with ChatGPT or Copilot and quietly suspects the tool is doing the learning. If you are already past that point and cannot debug anything you did not prompt, that is a repair job, not prevention, and the rest of this guide still gives you the drills to close the gap. ## The short version: use AI as a tutor, never as autocomplete Use AI to explain code, review your code, and quiz you. Never use it to write code you then paste and run. That is the whole method, and everything below is how to hold the line on it when you are tired and the deadline is close. Here is the part most advice skips: dependency is not a willpower problem. Nobody decides to stop learning. It happens by default, one small paste at a time, because pasting is faster than thinking and the result usually works. If your default action is "ask the AI for the code," you will become dependent no matter how disciplined you feel, the same way you finish the snacks that happen to be sitting on your desk. The only thing that reliably changes the outcome is changing the default, which is why the rest of this is a set of rules you decide once, not a motivation you summon daily. The vast majority of developers are already using or planning to use these tools (Stack Overflow's 2025 Developer Survey), so coding alongside AI is a given. Staying able to code without it is the part you have to defend. ## Why AI dependency happens (the cognitive-offloading trap) Dependency happens because your brain offloads any work it is allowed to skip, and AI lets it skip the hardest part: reasoning through the problem. Cognitive offloading is the habit of pushing mental work onto an external tool, and it is mostly automatic. Two 2025 studies make the pattern hard to ignore, with the caveat that neither is the final word. A 2025 MIT Media Lab study (Kosmyna et al., "Your Brain on ChatGPT," June 2025) had 54 people write essays with ChatGPT, with a search engine, or with no tools while wearing EEG headsets. The ChatGPT group showed the weakest brain connectivity, reported the lowest sense of ownership over what they wrote, and struggled to quote back essays they had just produced. It is a small, not-yet-peer-reviewed preprint about essay writing rather than coding, so read it as suggestive, not settled. Separately, in a 2025 study of 666 people (Gerlich, Societies, vol. 15, 2025), frequent AI-tool use was negatively correlated with critical-thinking scores, with younger and heavier users scoring lowest. That one is a correlation from self-reported surveys, not proof AI caused the drop. (A September 10, 2025 correction left its conclusions unaffected.) Put the two together and the mechanism is plain enough. When the tool does the reasoning, your brain treats that reasoning as handled and quietly stops encoding it. You feel like you learned something because you read a working answer. You did not, because reading an answer and being able to produce it are different skills, and only one of them gets tested in a job interview or a 2 a.m. outage. ## How dependent learners already are in 2026 (the data) Very, and the trend shows up in both the surveys and the code itself. Heavy use sits right next to low trust. Stack Overflow's 2025 Developer Survey, still the most recent published edition because the 2026 survey only opened on June 23, 2026, found that 84% of developers use or plan to use AI tools and 51% of professionals use them daily. Yet in that same survey more developers distrust the accuracy of AI output (46%) than trust it (33%), and only about 3% say they highly trust it. People lean on the tool constantly and believe it rarely. That gap is the dependency in miniature: the habit has outrun the judgment. The behavior shows up in the code too. GitClear's analysis of 211 million changed lines of code (January 2020 to December 2024) found copy-pasted ("cloned") lines rose from 8.3% in 2021 to 12.3% in 2024, while refactored ("moved") lines fell from 25% to under 10%, so in 2024 copy-pasted code outnumbered refactored code for the first time the firm has recorded. GitClear is a code-analytics vendor, and it associates the shift with AI-assistant adoption rather than proving AI caused it, so treat it as a direction, not a verdict. The direction is more pasting and less reshaping. And it has reached the point of refusal. When METR tried to re-run a developer-productivity experiment in early 2026, it hit a telling wall: 30% to 50% of developers declined to submit tasks because they did not want to do them without AI (METR, February 24, 2026). TechCrunch flagged the same trend under the headline "Coders are refusing to work without AI, and that could come back to bite them" (Julie Bort, May 29, 2026). These are working professionals, not beginners. If experienced developers will not give up the tool for a single task, a learner who started on it has further to fall. The junior market is already harder than it was (I cover that in [the junior developer job market in 2026](https://scrimbaguide.tech/blog/junior-developer-job-market-2026/)), and "can ship with AI, helpless without it" is not the profile that survives it. ## The method: six rules for learning with AI without the crutch The fix is six default changes, decided once. Before the rules, a 30-second self-test: open your last project and try to rewrite one function you supposedly wrote last week from a blank file, no AI, no peeking. If you cannot, the AI wrote it, not you, and you have your answer. The rules below are the defaults that prevent that result. - Type every line, even when the idea came from AI. Pasting and retyping produce the same file and completely different memories. If the tool shows you code, close it and rewrite it from understanding, not from the clipboard. - Default the prompt to "why," not "write." Ask the tool to explain a concept, walk through an error, or compare two approaches. The moment a prompt starts with "write a function that," you have switched from learning to ordering. - Write first, ask AI to review second. Produce your own broken version, then let the AI critique it. A reviewer makes you better; a ghostwriter makes you redundant. - Make it quiz you. Ask the AI to question you about the code you just wrote, or to hand you a bug to find. Reverse the arrow so you are the one answering. - Never keep code you cannot explain out loud. If you cannot say what a line does and why it is there, you do not get to keep it. This single rule catches most almost-right answers before they reach your project. - Schedule no-AI work. One project, or one weekday, built start to finish with the tool closed. This is the only rule that proves the other five are working. Five of these change what you ask for. The sixth checks that the change took. None of them ask for willpower in the moment, which is the point: a default you set on a calm Sunday beats a resolution you have to renew every time the tool is one tab away. For which tools actually help at each stage, I keep [a guide to AI tools for learning to code](https://scrimbaguide.tech/blog/ai-tools-for-learning-to-code-2026/) that treats them as study aids. ## Good prompts vs crutch prompts (copy-paste examples) The difference between a tutor prompt and a crutch prompt is whether you still have to think after you read the reply. Crutch prompt: "Write a React component that fetches users and shows a loading spinner." You get working code, paste it, and learn nothing, because the component made every decision you were supposed to make. Tutor prompt: "I wrote this component to fetch users and show a spinner. Here is my code. The spinner never goes away. Do not fix it. Ask me three questions that will help me find the bug myself." Now the reply hands the thinking back to you. A few more pairs, same logic. Instead of "Give me the regex for an email," try "Here is my regex attempt and what I think each part does. Where is my mental model wrong?" Instead of "Explain closures and write an example," try "Here is a closure I wrote. Predict what it logs, then tell me whether my prediction below is right and why." Instead of "Fix this error," try "Here is the error and the two things I have already checked. What category of bug is this, so I know where to look next?" The pattern repeats in every pair: you bring code or a guess, the AI sharpens your thinking instead of replacing it, and you finish the exchange able to do the thing again unassisted. The day you notice yourself pasting the AI's code in place of your own attempt is the day you slipped back to the crutch. That is the only signal you need to watch for. ## When it is actually fine to let AI drive It is fine once you can read and verify the output faster than you could have written it, and only on work whose correctness you can check at a glance. Whether AI writes the code was never the problem. The problem is whether you can read and check what it wrote. The 2025 Stack Overflow survey found the top developer frustration, named by 66%, is AI output that is "almost right, but not quite." Separately, 45% said debugging AI-generated code is more time-consuming than writing it themselves. Almost-right is the worst failure mode there is, because it compiles, it runs, it passes a five-second glance, and the bug surfaces three weeks later in production. The only defense is reading the code well enough to catch it, which is exactly the skill the crutch erodes. Even experts misjudge this. A METR randomized controlled trial published in July 2025 (arXiv:2507.09089) found that 16 experienced open-source developers, working in large repositories they already knew well, took 19% longer to finish tasks when allowed to use early-2025 AI tools (Cursor Pro with Claude 3.5 and 3.7 Sonnet), even though they estimated the tools had made them about 20% faster. It was a narrow study, experienced people in code they knew, and the tooling has moved since. The lasting point is not "AI is slow." It is that the people best equipped to judge AI output were still off by roughly 40 points about their own speed, so a beginner who cannot read the output at all is flying blind. Let AI drive boilerplate you have hand-written many times and can verify instantly. Keep it away from the concept you are still trying to learn. There is one ban worth keeping outside the six rules: close AI entirely, not just for writing, while you fix a race condition, decide which piece of code owns a value it shares with others, or touch a language feature for the first time. Those are the three moments a fluent-sounding wrong answer costs you the most, because you do not yet have the judgment to catch it. ## Practice where you literally cannot copy-paste The fastest way to enforce all six rules at once is to practice somewhere copy-paste does not help you. The format does the discipline so you do not have to. Reading and changing code in an environment where the answer is not one paste away forces the exact loop the method is built on: you type, you run, you get it wrong, you read your way back to right. A blank editor with ChatGPT open in the next tab is the opposite, because it makes the crutch the path of least resistance. This is also why passive video falls short. Watching someone else type builds recognition, and recognition collapses the moment you face a blank file (more on that gap in [why interactive practice beats coding videos](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-youtube/) and [why no-setup practice beats heavy tutorials](https://scrimbaguide.tech/blog/scrimba-instant-practice-no-setup/)). Scrimba is built around editing the instructor's code directly in the browser and running it, which is the method turned into a product: you cannot watch your way through it, you have to write. Its own AI feature respects the same rule: the EXPLAIN button in a lesson hands your highlighted code to [Scrimba Explain](https://scrimbaguide.tech/blog/scrimba-explain-review/), which explains it as a narrated video and never writes the answer for you. [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) is free and shows the mechanism at full scale: Per Borgen's 9.4-hour course stops the recording well over a hundred times and makes you write the fix yourself before it shows its own, across builds that include a blackjack game and a Chrome extension. Find out there whether forced-typing practice suits you before paying anything. If it clicks and you want the full sequence, the [frontend developer path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) runs on that format for all 81.6 hours, 13 modules and 1,493 lessons, and Scrimba Pro is a low monthly subscription (see current [Scrimba pricing](https://scrimbaguide.tech/docs/pricing/)). I point there because the argument of this whole piece is that you keep the skill by doing the work yourself, and a format where you physically edit and run the code is that rule enforced by design instead of by willpower. (More on what sets the format apart in [what makes Scrimba different](https://scrimbaguide.tech/blog/what-makes-scrimba-different/).) ## Can you explain these without AI? Run this check first Run this before the 30-day plan below, because it tells you which day one project to build. Six spots are where the crutch hides best, and each one has its own tell in production. | Topic | Ask yourself | If you can't, you'll see it as | | --- | --- | --- | | async/await + Promises | What is the code waiting on, and what runs before it finishes? | Random UI order, double submits, flaky tests | | Closures | Which variable does this inner function still remember after the outer one returns? | Stale counters, wrong callback values, small memory leaks | | undefined vs null + optional chaining | Why is this property missing instead of set to something? | White screens, "cannot read property of undefined" | | Array mutation vs new arrays | Did I change the array in place, or build a new one? | React skips the re-render and devtools show nothing wrong | | React state + batching | Where does this value actually live? | State fights, effect loops, a form that behaves differently on every load | | TypeScript errors | What is this error stopping me from shipping? | `any` everywhere, and type-checked bugs you shipped anyway | If you hesitate on more than two rows, do not start the 30-day plan yet. Fix the matching gap first with the courses below, then run the plan to prove it stuck. ## Map each gap to a Scrimba course One free course, one Pro supplement, and one more free course cover five of the six gaps above; the closures gap needs a course this guide has not linked yet, because the obvious pick skips it. | Gap | Course | Module that fixes it | | --- | --- | --- | | async/await + Promises | [The Tricky Parts of JavaScript](https://scrimbaguide.tech/docs/courses/javascript/tricky-parts-of-javascript/) | Its "Promises, fetch, Promise.all, async/await" module: 22 minutes of Zack Wilson rewriting the same fetch call three ways and making you predict what `Promise.all` logs before he runs it | | Closures | [Advanced JavaScript](https://scrimbaguide.tech/docs/courses/javascript/advanced-javascript/), not the two above | [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) never reaches closures, and Zack Wilson's own outro in Tricky Parts names closures as "what to learn next," not what his course teaches. Advanced JavaScript is the one on this site that does | | undefined vs null + TypeScript errors | [Learn TypeScript](https://scrimbaguide.tech/docs/courses/typescript/learn-typescript/) | Its "TypeScript Fundamentals" module: Bob Ziroll fixes "object is possibly undefined" with an `if` guard before he teaches the syntax for it, then makes you write the guard yourself | | Array mutation + React state | [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) | Its "React State" module, 5.2 hours across 57 lessons: you change one piece of state and watch the preview re-render beside your code, so the mutation bug that a static tutorial hides becomes visible the moment you cause it | [The Tricky Parts of JavaScript](https://scrimbaguide.tech/docs/courses/javascript/tricky-parts-of-javascript/) runs 59 minutes across 20 lessons on Scrimba's own count and needs Pro. [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/), [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) and [Learn TypeScript](https://scrimbaguide.tech/docs/courses/typescript/learn-typescript/) are all free. ## A 30-day plan to keep your raw coding skill while you use AI Spend 30 days proving you can still build without the tool, then fold AI back in as a tutor. Treat it as a month of running the defaults until they feel normal, not a one-time detox you do and forget. By the end, the tool is safe to use because your habits changed. Week 1: AI off for writing, on for explaining only. Build one tiny thing a day (a button, a small form, one function) typed entirely by you. When stuck, ask the AI to explain the concept, never to write the code. Week 2: add the review loop. Keep writing everything yourself, then paste your finished code into the AI and ask only "what is wrong with this and why," and fix it yourself. Week 3: add the quiz loop and a no-AI day. Have the AI generate bugs for you to find and questions to answer, and pick one weekday where the tool stays closed from morning to night. Week 4: ship one project start to finish with AI closed, then write a short post-mortem and ask the AI to critique the finished result. If you can build it without the tool, you own the skill. If you cannot, you have found exactly which concept you offloaded, and that is your next week. The trap throughout is the comfortable feeling of progress that comes from reading working code, the same feeling that keeps people stuck in [tutorial hell](https://scrimbaguide.tech/docs/how-it-works/tutorial-hell/). Real progress feels worse, because it is the friction of producing something yourself and getting it wrong. So here is the concrete first move, and you can make it in the next ten minutes. Open your most recent project, pick one function you supposedly wrote this month, delete it, and rewrite it from a blank file with every AI tool closed. Whether that feels easy or impossible is the only honest measure of how much you have been learning, and either answer tells you what to do next. ## Frequently asked questions How do I learn to code without becoming dependent on AI? Make AI explain instead of produce. Write every line yourself, ask the tool why your code is wrong rather than asking it for working code, and refuse to keep anything you cannot explain out loud. Dependency comes from default habits, not weak willpower, so the fix is changing the defaults, not trying harder each time. I forgot how to code without AI. Is that normal, and can I fix it? It is common, and a 2026 METR update found 30% to 50% of developers declined tasks they did not want to do without AI. This guide is about preventing that slide while you learn. If you already cannot debug anything you did not prompt, that is a repair job, and the going from vibe coder to real developer guide covers it directly. Will using AI to learn to code make me a worse programmer? It can, if you let it write code you do not understand. A 2025 MIT Media Lab study found people who wrote with ChatGPT showed weaker brain connectivity and struggled to quote essays they had just produced, and a 2025 study by Gerlich found frequent AI use correlated with lower critical-thinking scores. Used as a tutor that explains, AI helps; used as autocomplete, it hollows out the skill. How do I use ChatGPT to learn programming without copy-pasting code? Ask it to explain concepts, review code you wrote, or quiz you, and never ask it to hand you a finished function. When it does show code, retype it by hand instead of pasting so your memory stays involved. The test is simple: if you could not rewrite it from scratch tomorrow, you did not learn it. Is it ever fine to let AI write the code for me? Yes, once you can read and verify its output faster than you could write it yourself. The 2025 Stack Overflow survey found 66% of developers name code that is almost right but not quite as their top frustration, so the value of AI depends entirely on your ability to catch that. Let it drive on boilerplate you have written by hand many times, not on concepts you have never learned. How is using AI as a tutor different from using it as a crutch? A tutor makes you do the thinking and checks your work; a crutch does the thinking for you. With AI, that means prompting for explanations and reviews rather than solutions, and proving you understand each answer before you move on. The difference is not the tool, it is which default you set for how you use it. ## Practice where you can't paste The scrim format makes you type and fix code yourself, which is how recall actually forms. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # How to Learn DevOps in 2026: The Path, the Resources, and What to Pay For Source: https://scrimbaguide.tech/blog/how-to-learn-devops-2026/ Learn DevOps in this order: Linux, Git, Docker, a real deployment, environment variables and secrets, then continuous integration. Kubernetes comes last, and only if you want the DevOps job title rather than the ability to ship your own work. Before you start, spend ten minutes with the free roadmap at [roadmap.sh/devops](https://roadmap.sh/devops) so you can see how those pieces depend on each other. Every stage below has a good free resource and a good paid one: the free route costs you time and assembly, the paid route costs money and buys both back. Below is the path, the best resource for each step in both directions, and when paying is genuinely the better call. ## First, decide which of two goals you have DevOps as a job title covers Kubernetes clusters, infrastructure as code, on-call rotations, and platform teams. That is a multi-year career. Most people who say "I want to learn DevOps" want something much smaller: the layer between "it works on my machine" and "it is running where other people can use it." Those two goals share the first six steps and diverge hard after that. If you write software and want to ship it, you can stop after continuous integration and you are done. If you want DevOps on your business card, that is where the real curriculum starts. Deciding which one you are chasing is the single highest-leverage thing you can do, because chasing the full title when you wanted the deployment layer is the most common way people quit in week two. Two reasons the timing is good either way. Docker reached 71.1% adoption in the Stack Overflow 2025 Developer Survey after what the survey calls "a +17 point jump in usage from 2024 to 2025, the largest single-year increase of any technology surveyed." And when the same survey asked which tasks developers refuse to hand to AI, deployment and monitoring topped the list at 76%. The skill is becoming standard and staying human at the same time. ## DevOps is not a set of tools, and the name is half the problem Everything below this section is tools. I want to stop first, because the tools are the least interesting part, and learning them without the idea behind them is how people end up doing all the work and getting none of the benefit. The history explains the confusion better than any definition does. In 2006, Amazon's CTO Werner Vogels described the company's operating rule in an ACM Queue interview with a line that has outlived the interview: you build it, you run it. The team that writes the service carries the pager for it. In 2008, at the Agile conference in Toronto, Andrew Clay Shafer ran a session on "agile infrastructure", and Patrick Debois turned up because he was frustrated that operations work could not move the way development had learned to move. In June 2009, John Allspaw and Paul Hammond gave a talk at Velocity called [10+ Deploys Per Day: Dev and Ops Cooperation at Flickr](https://www.youtube.com/watch?v=LdOe18KhtT4), which proved the thing worked at scale. Then in October 2009 Debois organised [a conference in Ghent](https://devopsdays.org/about/) to keep the argument going. He needed a Twitter hashtag for it. He shortened "development and operations" to #DevOps, and the label stuck to a movement that already existed without it. Notice what is absent from that story: a single tool. Docker did not exist until 2013. Kubernetes and Terraform arrived in 2014. The idea is older than every tool you will use to implement it, which tells you the tools are an answer, not the question. The question was organisational. Developers were paid to ship change and operations were paid to prevent instability, so the two groups were structurally set against each other, and the work piled up at the wall between them. DevOps was an argument that the wall itself was the defect. When [Damon Edwards and John Willis summarised it in 2010](https://itrevolution.com/articles/devops-culture-part-1/) they used the acronym CAMS: culture, automation, measurement, sharing. Automation is one of four, and it is the only one you can buy. ### What the word means depends entirely on where you are standing This is the part that confuses beginners, and it is not their fault. The word genuinely means different things in different places. At a small company or on your own projects, DevOps is not a job, it is a hat you wear on Thursday. You wrote it, so you deploy it, and when it breaks at midnight there is no one else. This is where most self-taught developers actually live, and it is why the deployment layer in this article matters more to you than any org chart. At a mid-sized company, it usually is a role. Someone owns the pipelines, the environments, and the deployment tooling that everyone else uses. TechWorld with Nana makes this point well in [her explainer on what DevOps really is](https://youtu.be/0yWAtQ6wYNM): the original definition was "too broad and too high level" to act on, so companies each implemented it differently, and out of that a concrete job title emerged. She is blunt that the people who coined the term did not intend a "DevOps engineer" role, and equally blunt that the reality diverged from the theory anyway. I think she is right on both counts. At a large company, the work has mostly been renamed again, into platform engineering or SRE. Google's version, site reliability engineering, is best understood as one specific implementation of these ideas with error budgets and hard numbers attached. So when a job advert says DevOps, it can mean any of: write the pipelines, run the clusters, be on call, or be the person who unblocks forty developers. Read the responsibilities, never the title. ### What I actually think The tools list in this article is a snapshot of how the industry solves this problem in 2026, and it will date. The problem will not. Every tool here exists to shorten the distance between someone changing code and that change safely reaching a user, and to make sure the person who wrote it is the person who finds out when it breaks. I came up through peer-to-peer project work at 01Talent rather than a company with an operations department, and I build scrapers, which are the kind of software that runs unattended and fails quietly at three in the morning. Nobody hands you a runbook for that. You learn very fast that "it works on my machine" is not a technical statement about a machine, it is a statement about how little you know about where your code actually lives. That is the real reason to learn this material, and it is not on any roadmap. Not because Docker is popular. Because owning your software end to end changes how you write it in the first place. ## Before you start: get the map Start at [roadmap.sh/devops](https://roadmap.sh/devops). It is a free visual roadmap showing how Linux, Git, Docker, CI/CD, Terraform, Ansible, cloud platforms and monitoring connect, and roadmap.sh is one of the most starred projects on GitHub. Use it as a map, not a checklist. Here is a slice of the middle of it, and the sprawl is the point: That is one screen of several, and you will never touch most of those boxes. Its value is not the list. It is that it shows what depends on what, which is exactly the knowledge that stops you spending a fortnight on Kubernetes before you understand Linux file permissions. ## The path, step by step Each step names the best free resource and, where one meaningfully beats it, the paid option worth the money. 1. Linux and the prerequisites. freeCodeCamp's [DevOps Prerequisites Course](https://www.freecodecamp.org/news/devops-prerequisites-course/) runs about three hours and was produced with KodeKloud. It covers Linux basics, building a lab environment with VirtualBox and Vagrant, and reading YAML and JSON. Every tool later in this list assumes all three, and skipping it is why people find Kubernetes manifests incomprehensible. 2. Git. Branching, pull requests, and reading a diff. You need this before CI, because CI is just "run these commands when the repository changes." If you are already using Git for your own projects you can move on. 3. Docker. [TechWorld with Nana's Docker Tutorial for Beginners](https://www.youtube.com/c/TechWorldwithNana) is a free three-hour YouTube course and is the single most recommended free Docker resource for good reason. Nana explains the mental model rather than reciting commands. Pair it with KodeKloud's free "Docker Training Course for the Absolute Beginner," which adds browser-based labs so you type rather than watch, and keep [Docker's own getting-started guide](https://docs.docker.com/get-started/) open as the reference you check when a command does not behave. The step nobody tells you: as soon as the tutorial ends, containerise an application you already wrote. Tutorial containers always work. Yours will not, and the debugging is the actual learning. 4. A real deployment. Take the container and put it on a managed host. [Render](https://render.com/), [Railway](https://railway.com/) and [Fly.io](https://fly.io/) all have free or cheap tiers, and none of them require you to understand cloud networking on day one. The goal is a URL you can send someone, not an optimal architecture. 5. Secrets and environment variables. Get configuration out of your code and out of your repository. This is a short topic with an expensive failure mode: leaked API keys in public Git history are one of the most common beginner mistakes and one of the hardest to fully undo. 6. Continuous integration. The [GitHub Actions documentation](https://docs.github.com/en/actions) is free, current, and better than most paid courses on the subject. Write one workflow file that installs dependencies and runs your tests on every push. That is CI. Everything else is elaboration. Where paying beats the free route on this path: steps 1, 3 and 7 are the ones where a paid platform genuinely pulls ahead, because all three want hands-on environments rather than more video. KodeKloud's paid tier turns each into guided labs with a terminal, which is a different activity from watching Nana and then staring at an empty editor. Steps 2, 4, 5 and 6 are well enough covered free that paying adds little. 7. Kubernetes, only if you want the title. [Nana's Kubernetes Tutorial for Beginners](https://www.youtube.com/c/TechWorldwithNana) is a free four-hour course, and there is a shorter 1 hour 12 minute crash course if you want the concepts first. KodeKloud's free "Crash Course: Kubernetes For Absolute Beginners" covers similar ground with labs. If you are a web developer who wanted to ship your side project, you can stop at step 6 with a clear conscience. Kubernetes solves problems you do not have yet. ## Should you pay? It is time versus money, not discipline The free route is not the smart route and the paid route is not the lazy one. They trade different things, and pretending otherwise has probably cost more people more time than any bad course ever did. Free costs you assembly. You decide the order, stitch resources from five sources, discover the gaps yourself, and lose hours to setup that a browser lab would have skipped. If you have more time than money, that is a fine trade and the path above is genuinely complete. Paying buys back time and removes decisions. A good platform sequences the material, hands you a pre-built environment, and tells you what comes next, which matters most if you are studying around a job, changing careers against a deadline, or preparing for a certification with a date on it. At roughly the price of a couple of coffees a month, the arithmetic gets easy: if a paid platform saves you five hours in a month, it has paid for itself against almost any hourly value you put on your own time. Here is what the three main options actually give you. | | [KodeKloud](https://kodekloud.com/pricing) | [TechWorld with Nana Bootcamp](https://www.techworld-with-nana.com/devops-bootcamp) | [Scrimba Intro to DevOps](https://scrimba.com/intro-to-devops-c0tjgdu6ks?via=u42d4986) | | --- | --- | --- | --- | | Shape | 130+ courses, 1,280+ hands-on labs | Structured bootcamp, 4 to 6 months | One 5.5-hour course inside a wider subscription | | Scope | Docker, Kubernetes, Terraform, Linux, cloud, certification prep | Docker, Kubernetes, Jenkins, Terraform, Ansible, Helm, monitoring | Containers and Docker, deployment with Render, CI | | Level | Beginner through certification | Beginner to job-ready | Intermediate, assumes you can build an app | | Free tier | 25+ free courses and labs, account required | Free crash courses on YouTube | Other Scrimba courses are free, this one is not | | Best for | Certification prep and deep hands-on labs | People targeting a DevOps job title | Web developers who want to ship what they build | Bottom line: if you want the DevOps job title and a deadline, KodeKloud is the strongest value for hands-on practice and certification prep, and Nana's bootcamp is the most structured route to job-ready. If you are a web developer who mainly needs to ship what you build, Scrimba's course is the tighter fit, which I come to below. And if money is the binding constraint, the free path above still gets you there, just slower. ## Where Scrimba fits, and who should ignore it I reviewed [Intro to DevOps](https://scrimbaguide.tech/docs/courses/javascript/devops/) inside a Pro account, and I check every claim below against the free options above rather than taking the course's own marketing at its word. Scrimba shipped [Intro to DevOps](https://scrimba.com/intro-to-devops-c0tjgdu6ks?via=u42d4986) on 10 August 2026, taught by DonTheDeveloper. It runs 84 lessons across about five and a half hours, is marked Intermediate, requires Pro, and has picked up 4,000-plus students with captions in ten languages. There is a free 2:10 sample lesson, so you can see the format before deciding anything. It is a better course than its own marketing suggests. Here is the shape of it: | Module | Lessons | Time | What it actually covers | | --- | --- | --- | --- | | Containers and Docker | 14 | 64 min | Images, Docker Hub, bind mounts, named volumes, Docker Compose | | Deployment | 11 | 75 min | Render build commands, smoke tests, domains, staging, health endpoints, signal handling | | Continuous Integration | 22 | 75 min | GitHub Actions YAML, Prettier, ESLint, Docker Hub auth via secrets, PR status checks, branch rulesets | | Continuous Delivery | 14 | 92 min | Neon database, automated migrations, feature flags, rollbacks, deploying to production | | CDNs | - | 23 min | Origin server problems, caching, DDoS protection, edge functions, gotchas | Look at the Continuous Delivery module in particular. It teaches backward-compatible database migrations through the full expand, backfill, prepare, switch and contract sequence, then feature flags and rollbacks. That is a professional operational pattern rather than beginner filler, and an unusual thing to find in a course called "Intro to". The CI module is similarly concrete: you write a real GitHub Actions YAML file, watch it fail, then add Prettier, ESLint and a Docker Hub push job to it, with credentials handled through GitHub secrets rather than pasted in. The format is the other half of the case, and it matters more here than in most subjects: That is a real project, not a slide: a Node microblog with a Dockerfile, a live preview running on port 3000, and a terminal. When you click into the code, the player switches to your copy of it and offers a "back to teacher" button to return to the instructor's version: That button is the whole pedagogical argument in one control. You can stop the lesson at any line, edit the instructor's Dockerfile, and jump back to their version when you want to. The stated prerequisite is more welcoming than the Intermediate badge suggests: it is "designed for developers who already understand the basics of building applications", and "you don't need any previous DevOps, Docker, deployment, or CI/CD experience". Intermediate here means you can build an app, not that you have done ops before. Consider it if you are a web developer who can already build applications and your real problem is that your projects live on localhost. The course maps almost exactly onto steps 3 to 6 of the path above, in order, with the sequencing decided for you. If you are already paying for Pro to follow a Scrimba path, it costs nothing extra and is the obvious next thing to do. Ignore it if you want the DevOps job title. It teaches you to ship one application well; it does not touch Kubernetes, Terraform, Ansible or infrastructure at scale, and KodeKloud goes far deeper for less. Ignore it too if you cannot yet build an application on your own, since that is the one prerequisite Scrimba actually states. And ignore it if you are not otherwise interested in Scrimba, because Pro is a subscription decision rather than a course decision. Prices vary by region, so see our [pricing breakdown](https://scrimbaguide.tech/docs/pricing/) or [Scrimba's own pricing page](https://scrimba.com/our-pricing?via=u42d4986). Two limits beyond scope. Deployment is taught on Render, so the concepts transfer but the buttons do not, and a job asking for AWS needs a second learning curve. The course also has almost no public footprint: no trailer, no reviews, nothing from either instructor. That says nothing about quality, but it does mean you are buying largely unseen. Watch the free sample lesson first. ## Where to practise Reading about containers teaches you nothing. You need a terminal, and you have three options. [Killercoda](https://killercoda.com/) gives you browser-based Linux and Kubernetes environments with guided scenarios and a genuinely perpetual free tier, not a trial. It is actively maintained and has scenarios aimed at the current CKA exam. [KodeKloud's free tier](https://kodekloud.com/free-courses) is the other strong browser option, and it is the one I would pick if you want labs attached to a course rather than standalone scenarios. Its paid plans carry 1,280+ hands-on labs across Git, Docker, Kubernetes and Terraform, and the free courses include real lab environments too. The third is your own machine. Install Docker locally and use it, because the friction of a real setup is itself part of the skill, and it is the setup you will have at work. This is the part I think beginners undervalue most, so I want to be specific about it. The hard problem in learning infrastructure is not understanding what a pod is. It is that you cannot practise infrastructure on nothing. A video can explain a cluster; it cannot give you one. And the systems you most need to practise on are precisely the ones you cannot conjure on a laptop: a multi-node cluster, a broken deployment somebody else wrote, a service that fails only under load, a pipeline with a real repository behind it. What platforms like KodeKloud and Killercoda actually sell is that missing environment. You get a disposable world with a terminal attached, organised by the tool you are trying to learn: Note what that catalogue is counting. Not videos: labs. Twenty-six separate Terraform environments, twenty Linux ones, fifteen for Git. Here is what one of them looks like from the inside, which is the part the marketing pages never show you: That is the whole argument in one screen. The question on the left cannot be answered from memory or from the video; you have to go into the shell on the right, run `docker version` against a machine that actually exists, and read the answer out of the output. The host is real, you are root on it, and there is a timer because it is a live container that costs somebody money to run. The Kubernetes labs give you an actual cluster rather than a single host, and this is where the value gets hard to replicate on a laptop: Read what the second command returns. That is not a diagram of a cluster, it is a cluster: CoreDNS resolving service names, a local-path provisioner handing out volumes, Traefik installed by a Helm job and fronted by a service load balancer, and a metrics server feeding resource data. Standing that up on your own machine is an afternoon of yak-shaving before you have learned anything about Kubernetes. Here it existed before you arrived, and you get root on the control plane. The question on the left is "how many nodes are part of the cluster", and the answer comes out of the terminal on the right. You cannot guess it, and watching a video will not tell you. [Killercoda](https://killercoda.com/) does the same thing in a different shape, handing you an empty two-node Kubeadm cluster in the browser with the control-plane taint already removed so you can schedule work on it. ### The version that looks like an actual job There is a step beyond single-topic labs, and it is the closest thing to real work a browser can give you. [KodeKloud Engineer](https://engineer.kodekloud.com/) drops you into a fictional company, xFusionCorp Industries, as a system administrator on Project Nautilus, and then gives you tickets. The company has documentation, and the documentation is the point: Yes, that is a full credential table sitting in public documentation, and yes, I am publishing it. Before you file a CVE: the users are the Avengers, `thor` guards the jump host with `mjolnir123`, and the Jenkins box logs in as `j@rv!s`. Every one of those machines is destroyed and rebuilt per session. If a password table ever gives you that little anxiety at work, something has gone very right. Read past the joke and look at the estate. Ten servers with hostnames and owners: three application servers behind an Nginx load balancer, a MariaDB database, network-attached storage, a backup host, a mail server, a Jenkins box for CI/CD, and a jump host that is the only way in. That is an ordinary three-tier architecture, documented the way a real one would be, down to which colleague owns which machine. The tasks then arrive as tickets against that estate rather than as exercises. Fix the failed service on stapp02. Set up the cron job on stbkp01. Give a new starter access through the jump host. You have to read the architecture before you can act, because nothing tells you which box to log into, and reaching `stdb01` means going through `jump-host` first, exactly as it would at work. This is the closest a browser gets to the thing that is genuinely hard to practise alone: not a tool, but an estate you did not design, with conventions you have to learn and a topology you have to navigate. If you want to know whether infrastructure work suits you, an afternoon here tells you more than a month of tutorials. The task design matters as much as the sandbox. A good lab does not ask you to type commands from a transcript. It hands you a cluster where something is already wrong and asks you to find it, which is the actual job. That is why lab platforms are worth paying for in a way that video courses often are not: you can get explanation free from Nana all day, but you cannot get a broken cluster free, and the broken cluster is where the learning happens. The limits: these environments are disposable and reset, so you never feel the weight of a system you have to live with, and a curated failure is easier than a real one because somebody chose it to be instructive. Neither is a reason to skip them. Both are reasons to move to your own project afterwards. ## Which certifications are worth it, and what they cost Certifications help most when you are trying to get past HR filters for infrastructure roles without matching job history, because this is one of the few corners of software where hiring managers genuinely recognise them. They help least if you are a web developer adding deployment skills, since nobody has ever asked a frontend candidate for a CKA. Prices below are the standard exam fees as of September 2026 and exclude local tax. | Certification | Cost | Format | Notes | | --- | --- | --- | --- | | KCNA (Kubernetes and Cloud Native Associate) | $250 | Multiple choice, 90 min, 75% to pass | One free retake included. The best first one. | | CKA (Certified Kubernetes Administrator) | $395 | Hands-on, live cluster | Two attempts included. The one employers name. | | CKAD / CKS | $395 each | Hands-on | Developer and security specialisations. Later. | | HashiCorp Terraform Associate | $70.50 | Multiple choice | Cheapest credible option. Valid two years, no free retake. | | AWS Certified Cloud Practitioner | $100 | Multiple choice | Entry-level cloud vocabulary, not a DevOps credential on its own. | | GitHub Foundations (GH-900) | $99 | 75 questions, 120 min, 70% to pass | Valid three years. Useful early if Git is still shaky. | | GitHub Actions (GH-200) | $99 | Multiple choice, 100 min | Intermediate. The most directly useful one for CI. | Bottom line: if you want the DevOps job title, the sequence that gets the most return per dollar is Terraform Associate or GitHub Actions first as a cheap confidence check, then KCNA, then CKA when you can actually drive a cluster. If you are a web developer, skip all of them and put the money toward a platform subscription instead. No certification substitutes for having deployed something and broken it. The exam proves you can pass the exam, nothing more. ## Where Udemy fits: exam prep, not credentials One thing first, because it decides how you should use the platform. A Udemy certificate of completion is worth nothing to an employer. It certifies that video finished playing. Nobody screens for it, nobody asks about it, and it belongs nowhere near the certifications section of your CV. If you are buying a Udemy course for the certificate, do not buy it. What Udemy is genuinely good at is being cheap, one-time-purchase preparation for the exams in the table above, the ones that do carry weight. You buy a course, you keep it, and on sale these typically land in the $10 to $20 range, which is a rounding error against a $395 exam fee. Used that way it is one of the best-value things on this page. So pair them deliberately. Each course below prepares you for a specific credential, and the credential is the thing that goes on your CV. | Credential you are chasing | Exam fee | Udemy course that prepares you | | --- | --- | --- | | CKA (Certified Kubernetes Administrator) | $395 | [Certified Kubernetes Administrator (CKA) with Practice Tests](https://trk.udemy.com/3ka77A), Mumshad Mannambeth | | HashiCorp Terraform Associate | $70.50 | [HashiCorp Certified: Terraform Associate 2026](https://trk.udemy.com/vDv22N), Zeal Vora | | AWS Certified Cloud Practitioner | $100 | [Ultimate AWS Certified Cloud Practitioner CLF-C02](https://trk.udemy.com/4aAddG), Stephane Maarek | The CKA course is the standard recommendation for that exam, and its practice tests are the reason: they are the closest thing to the real hands-on format outside the exam itself. Worth knowing that Mannambeth founded KodeKloud, so the course previews that teaching style if you are also weighing the subscription. Zeal Vora's Terraform course is built around the current certification blueprint and ends in practice tests. Maarek has taught AWS certifications to millions of students and keeps the course current with the CLF-C02 revision, which matters because AWS changes exam versions regularly. One gap worth naming: for KCNA, the Udemy listings are dominated by practice-question packs of uneven quality with no clear standout, so use the official CNCF curriculum and a labs platform instead. Docker is not on the list above because the credentials that matter for containers are the Kubernetes ones, and Docker itself is well covered by the free resources earlier in this post. Whatever you buy, check the last-updated date before paying. Udemy will happily keep selling a course built for a retired exam version, and a certification prep course that is out of date is worse than none. If you want a wider view of the platform, we keep a set of [Udemy course guides](https://scrimbaguide.tech/blog/best-udemy-coding-courses/), and our guide to [what course certificates actually do](https://scrimbaguide.tech/blog/complete-guide-scrimba-certificates/) covers the completion-certificate question in more depth. ## Where this sits next to everything else you are learning Deployment is one skill in a stack, and it pays off differently depending on the rest of it. On the [Frontend Developer path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) this is what turns a repository into a link you can send someone, which is the single biggest upgrade a portfolio can get. On the [Fullstack](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) and [Backend](https://scrimbaguide.tech/docs/paths/backend-developer-path/) paths it sits closer to the core, since running services other people depend on is a larger share of the job. Both paths stop short of this material by design: our [Backend path review](https://scrimbaguide.tech/blog/scrimba-backend-path-review/) notes that Docker and CI/CD are the gap employers ask about, and the [Fullstack path review](https://scrimbaguide.tech/blog/scrimba-fullstack-path-reviews/) says the same about deeper DevOps work. Two neighbours are worth sequencing around it. [Git and GitHub](https://scrimbaguide.tech/docs/courses/javascript/git-and-github/) come first, for the reason in step 2. Databases usually come next, and the free [Learn SQL course](https://scrimbaguide.tech/docs/courses/backend/sql/) is the cheapest way to find out whether backend work suits you at all, and the wider [backend catalog](https://scrimbaguide.tech/docs/courses/backend/) shows what follows. Continuous integration in step 6 also has a natural partner: the tests it runs. If your pipeline has nothing to execute, CI is just a green checkmark, and Scrimba's [Introduction to Unit Testing](https://scrimbaguide.tech/docs/courses/javascript/unit-testing/) covers the habit that gives it something to check. And if you are still choosing a direction rather than a tool, [which coding path to learn in 2026](https://scrimbaguide.tech/blog/which-coding-path-to-learn-2026/) compares the four tracks on job-market grounds, while the [Path Advisor](https://scrimbaguide.tech/tools/which-scrimba-path/) does it in about a minute. ## What no course gives you Every option on this page, free or paid, is a rehearsal. The tooling is chosen for you, the application is known to work, and the failures are the instructive ones. Real deployment is mostly debugging things nobody warned you about, like a build that passes locally and dies in CI over a case-sensitive filename. One specific limit applies to all the beginner material above: deploying to Render or Railway is not the same as deploying on AWS, Google Cloud, or a self-managed server, and job postings name those directly. The concepts transfer well. The button locations do not. So convert whichever route you pick into your own project immediately. Containerise something you built, deploy it, break it on purpose, and fix it. That debugging is what becomes an interview answer, and it is the only part none of these resources can hand you. Deployed projects are also among the few things that substitute for job history, which is the wider argument in [how to get coding experience without a job](https://scrimbaguide.tech/blog/how-to-get-coding-experience-without-a-job-2026/). If you want deeper reading once the practical work is underway, all three of Google's [Site Reliability Engineering books](https://sre.google/books/) are free online and are the best writing available on what running systems actually involves. ## References - [Stack Overflow 2025 Developer Survey, Technology](https://survey.stackoverflow.co/2025/technology) - Docker at 71.1% adoption and the +17 point jump described as the largest single-year increase of any technology surveyed. - [Stack Overflow 2025 Developer Survey, AI](https://survey.stackoverflow.co/2025/ai) - 76% of developers declining to use AI for deployment and monitoring, the highest of any task surveyed. - [roadmap.sh DevOps roadmap](https://roadmap.sh/devops) - the free step-by-step map of tools and their dependencies. - [freeCodeCamp DevOps Prerequisites Course](https://www.freecodecamp.org/news/devops-prerequisites-course/) - the free three-hour Linux, YAML and lab-environment primer produced with KodeKloud. - [TechWorld with Nana](https://www.youtube.com/c/TechWorldwithNana) - free Docker (about 3 hours) and Kubernetes (about 4 hours) tutorials, plus a 1 hour 12 minute Kubernetes crash course. - [KodeKloud free courses](https://kodekloud.com/free-courses) - 25+ free courses including Docker and Kubernetes for absolute beginners, with browser labs. - [Killercoda](https://killercoda.com/) - free browser-based Linux and Kubernetes environments, with a perpetual free tier. - [KodeKloud Engineer, Project Nautilus documentation](https://kodekloudhub.github.io/kodekloud-engineer/docs/projects/nautilus) - the xFusionCorp three-tier architecture, shared services, and the ten-server infrastructure table. - [CNCF KCNA certification](https://www.cncf.io/training/certification/kcna/) - exam format and the $250 price including a free retake. - [HashiCorp Terraform Associate certification](https://developer.hashicorp.com/certifications/infrastructure-automation) - the $70.50 exam fee and two-year validity. - [AWS Certified Cloud Practitioner](https://aws.amazon.com/certification/certified-cloud-practitioner/) - the $100 exam fee. - [GitHub certifications](https://resources.github.com/learn/certifications/) - the $99 fee, GH-900 format, and three-year validity. - [devopsdays: about](https://devopsdays.org/about/) - the first DevOpsDays in Ghent, October 2009, and Patrick Debois's role in organising it. - [10+ Deploys Per Day: Dev and Ops Cooperation at Flickr](https://www.youtube.com/watch?v=LdOe18KhtT4) - Allspaw and Hammond at Velocity, June 2009, the talk that showed it working in production. - [IT Revolution on DevOps culture](https://itrevolution.com/articles/devops-culture-part-1/) - the CAMS framing (culture, automation, measurement, sharing) from Damon Edwards and John Willis. - [TechWorld with Nana: What is DevOps? REALLY understand it](https://youtu.be/0yWAtQ6wYNM) - the argument that the original definition was too broad to act on, so each company implemented it differently and a job title emerged from that. - [Google SRE books](https://sre.google/books/) - all three titles free to read online. - [Scrimba, Intro to DevOps](https://scrimba.com/intro-to-devops-c0tjgdu6ks?via=u42d4986) - course scope, publication date of 10 August 2026, lesson count, runtime, and instructors. **Q: Where did the term DevOps come from?** Patrick Debois organised the first DevOpsDays conference in Ghent in October 2009 and needed a Twitter hashtag, so he shortened development and operations to #DevOps. The ideas predate the label: Werner Vogels described Amazon's you-build-it-you-run-it rule in 2006, Andrew Clay Shafer ran an agile infrastructure session at Agile 2008, and Allspaw and Hammond's 10+ Deploys Per Day talk at Velocity in June 2009 showed it working at Flickr. No tool appears in that story. Docker arrived in 2013, Kubernetes and Terraform in 2014. **Q: Is DevOps a role, a culture, or a set of tools?** It depends where you are standing, which is why the word confuses people. On your own projects it is a hat you wear rather than a job: you wrote it, so you deploy it. At mid-sized companies it is usually a real role owning pipelines and environments, even though the people who coined the term did not intend that. At large companies the work is often renamed platform engineering or SRE. When you read a job advert, read the responsibilities and ignore the title. **Q: How do I learn DevOps for free in 2026?** The full path is available free. Use roadmap.sh/devops for the map, freeCodeCamp's three-hour DevOps Prerequisites Course for Linux and YAML, TechWorld with Nana's free Docker and Kubernetes tutorials on YouTube, KodeKloud's 25+ free courses for browser labs, the GitHub Actions documentation for CI, and Killercoda for free hands-on environments. The cost is your own time: you assemble the order, find the gaps, and handle setup yourself. **Q: Is it worth paying to learn DevOps?** It depends on whether time or money is your binding constraint, not on discipline. Paying buys sequencing, pre-built lab environments, and someone deciding what comes next, which matters most if you are studying around a job, changing careers against a deadline, or sitting a certification. If a paid platform saves you five hours in a month it has already paid for itself. If you have more time than money, the free path is genuinely complete. **Q: What order should I learn DevOps in?** The roadmap first, then Linux and YAML, then Git, then Docker, then a real deployment to a managed host, then secrets and environment variables, then continuous integration. Kubernetes comes last and only if you want a DevOps job title. Most web developers can stop after CI, because Kubernetes solves problems they do not have yet. **Q: Is KodeKloud or TechWorld with Nana better for learning DevOps?** They serve different needs. Nana's free YouTube tutorials are the best free explanations of Docker and Kubernetes and her paid bootcamp is a structured 4 to 6 month route to job-ready. KodeKloud is stronger on hands-on labs, with 1,280+ browser lab environments and the most established certification prep for CKA, CKAD and CKS. Many people use Nana to understand and KodeKloud to practise. **Q: Which DevOps certification should I get first in 2026?** Start cheap. The HashiCorp Terraform Associate is $70.50 and GitHub Actions (GH-200) is $99, and either works as a low-cost check on whether you enjoy the material. Then KCNA at $250, which includes a free retake and is multiple choice. Leave the CKA at $395 until you can actually drive a live cluster, since it is a hands-on exam. **Q: Is a Udemy certificate worth anything for a DevOps job?** No. A Udemy certificate of completion certifies that a video finished playing, and no employer screens for it. Keep it off the certifications section of your CV. Udemy is worth using as cheap exam preparation for credentials that do carry weight, such as the CKA, the HashiCorp Terraform Associate, and the AWS Cloud Practitioner, where a course on sale for $10 to $20 is a rounding error against the exam fee. **Q: Which Udemy course should I buy for DevOps certification prep?** Match the course to the credential rather than buying broadly. For the CKA, Mumshad Mannambeth's Certified Kubernetes Administrator with Practice Tests is the standard pick and its practice tests mirror the hands-on exam format. For the Terraform Associate, Zeal Vora's course is built on the current blueprint. For the AWS Cloud Practitioner, Stephane Maarek's CLF-C02 course is kept current. Always check the last-updated date, since exam versions change. **Q: Should I take Scrimba's Intro to DevOps course?** Only if you are a web developer who can already build applications and whose real problem is that projects stay on localhost. It covers containers, Docker, Render deployment and CI in 84 lessons over about five and a half hours, is marked Intermediate, and requires Pro. If you want the DevOps job title, KodeKloud and Nana go far deeper for less or nothing. What Scrimba adds is sequencing and a browser editor with no local Docker setup. See our [full review](https://scrimbaguide.tech/docs/courses/javascript/devops/) for the module-by-module breakdown. ## If sequencing is what stops you finishing Try Scrimba free to see the format, then Intro to DevOps and the Frontend, Fullstack, and Backend paths are there when you're ready to go Pro. The free routes above work too. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # How to Prompt Scrimba Explain: Teaching Styles, Audience, Attachments Source: https://scrimbaguide.tech/blog/how-to-use-scrimba-explain-prompts-and-teaching-styles/ A good Scrimba Explain prompt names the topic, the audience, and the slides you want. I ran the same RAG prompt through three teaching styles, attached a Markdown file, and built a three-lesson playlist, seven explainers in total. Professor was not noticeably deeper than Standard, which suggests the prompt text, not the picker, sets the depth. If you do not know what Explain is yet, the [reference page](https://scrimbaguide.tech/docs/how-it-works/scrimba-explain/) covers entry points and quotas, and the [full review](https://scrimbaguide.tech/blog/scrimba-explain-review/) covers whether the output is any good. This post is only about the web composer at [scrimba.com/explain](https://scrimba.com/explain?via=u42d4986): what to type, which style to pick, and which clicks cost you an explainer. ## The three ingredients of a prompt Scrimba's prompting guide says a prompt needs a topic, an audience, and the slide types you want ([docs.scrimba.com/explain/prompting](https://docs.scrimba.com/explain/prompting?via=u42d4986)). Explain decides the structure and layout itself. You can also name an art style for all the images, such as hand-drawn or blueprint, and you can push the depth past whatever the teaching style implies. The docs call the audience line "the sentence most people leave out". I did not test a prompt without one, so I cannot show you what "Explain RAG" alone produces. Every explainer I ran with an audience line stayed on that audience. "For a JavaScript developer who has called an LLM API once" got JavaScript instead of Python and a pipeline that ends in a prompt string. The style comparison below suggests the picker moves the output less than the prompt text does. ![Scrimba Explain, prompt anatomy diagram: topic, audience and format feed into the slide types.](https://scrimbaguide.tech/img/blog/how-to-use-scrimba-explain-prompts-and-teaching-styles/prompt-anatomy.webp) *Topic, audience and format go in together. The teaching style is a separate picker, and the slide types you ask for are the ones you get.* ## The same RAG prompt in three teaching styles Teaching styles are a web-only picker that changes both the writing and the voice ([docs.scrimba.com/explain/teaching-styles](https://docs.scrimba.com/explain/teaching-styles?via=u42d4986)). To see how much they change, I submitted this prompt three times, word for word, and only moved the picker. ``` Explain how retrieval-augmented generation (RAG) works, for a JavaScript developer who has called an LLM API once and wants to build a chatbot that answers questions from their own docs. Cover why you cannot paste every doc into the prompt, chunking, embeddings, similarity search, and how the retrieved chunks end up in the prompt. Include one pipeline diagram slide with the ingest path and the query path, one JavaScript code slide that embeds a query and runs a cosine-similarity search over an in-memory array (JavaScript, not Python), and finish with a quiz. ``` RAG (retrieval-augmented generation) is the pattern where you search your own documents for relevant chunks and paste only those into the prompt. Guil Hernandez teaches it in [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/), 22 scrims and 94 minutes that end in a movie-recommendation chatbot on a Supabase vector store. I picked this topic because I had already read that curriculum and could check Explain's output against it. ![Scrimba Explain composer: the teaching style dropdown open with seven style options listed.](https://scrimbaguide.tech/img/blog/how-to-use-scrimba-explain-prompts-and-teaching-styles/explain-composer-teaching-style-menu.webp) *The style menu opens from the chevron on the Explain button. The choice persists across page loads, so check it before every submit.* | Style | Explainer | Length | Transcript headings | | --- | --- | --- | --- | | Explain (default) | [Retrieval-Augmented Generation (RAG)](https://scrimba.com/explain/guide0niu04ksn) | 1:22 | The context window problem, Chunking your data, The RAG Pipeline, Finding the right chunks, The final prompt, Test your knowledge | | Standard | [How RAG Works](https://scrimba.com/explain/guide0sp3ljm85) | 1:28 | The context window problem, The RAG pipeline, Chunking and Embeddings, Similarity search, Finding similar chunks, The final prompt, Test your knowledge | | Professor | [How RAG Works](https://scrimba.com/explain/guide050741s62) | 1:32 | The context window limit, The RAG pipeline, What is an embedding?, Similarity search in JS, The augmented prompt, Your turn | All three delivered the requested slides: an animation, a pipeline diagram, a `search.js` code slide, a second code slide that builds the prompt, and a quiz. All three stayed in JavaScript. The differences were smaller than the taglines suggest. The Explain version leaned on an analogy (an exam desk with too many books) and used shorter sentences. It also had the one slip of the batch: the code comment calls a plain dot product "cosine similarity", which is only true when the vectors are normalised. The concept explanation around it was fine, but if you copied that snippet you would ship a subtle bug. The Professor version had two of its own: a vector written as `[0.1, 0.9, ...]`, which is a SyntaxError, and a prompt template that used a `userQuery` it never defined. I fixed all three the next day with Redo slide (right-click the slide, one sentence of instruction, about 20 seconds each, free), so the links below now play the corrected slides; the durations in the table are after the fix. The lesson stands: without code you give it, Explain will write plausible code that does not run. The Standard version fixed that. Its `cosineSimilarity(vecA, vecB)` divides by both magnitudes, and its ingest and query paths were the clearest of the three. It is embedded below, so you can watch the one I would keep without leaving the page. The Standard version, 1:28. The cosineSimilarity code slide is the one of the three that divides by both magnitudes.[Open on scrimba.com](https://scrimba.com/explain/guide0sp3ljm85) ![Scrimba Explain, Professor style RAG explainer: the finished player with its transcript headings below.](https://scrimbaguide.tech/img/blog/how-to-use-scrimba-explain-prompts-and-teaching-styles/explain-professor-style-rag-explainer-transcript.webp) *Professor matched Standard's slide types and ran four seconds longer, its one addition a worked example of embedding vectors.* Professor promises "Maximum depth, down to the bytes". At this prompt length it did not deliver that. It added a `docs` array with example vectors and a nice intuition (JavaScript and Python embed close together, baking bread lands far away), but no wire formats, no memory layout, nothing Standard lacked. My reading: the prompt already pinned the depth, and the style could not push past it. The docs say depth comes mainly from the teacher you pick and that the prompt can amplify it. In my run the prompt did most of the work, so I would put the detail in the prompt and treat the style as a bonus. ## Attaching a document The composer accepts code files, Markdown, READMEs, logs, PDFs, images and Jupyter notebooks. Drag a file onto the box, use the paperclip, or paste a large block of text and Explain converts it into an attachment ([docs.scrimba.com/explain/attaching-documents](https://docs.scrimba.com/explain/attaching-documents?via=u42d4986)). The docs state no size or file count limit, and they say nothing about how uploads are stored. I attached a 98-line Markdown file I had written about the MCP lifecycle and transports. MCP (Model Context Protocol) is the standard that lets an AI agent call tools on a server. Maham Codes teaches it in [Intro to Model Context Protocol (MCP)](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/), 17 scrims where you build a weather MCP server in Node.js and TypeScript over a STDIO transport, the same transport my attachment covered. The prompt: ``` Explain this document for a Node.js developer who wants to build their first MCP server. Focus on what a server offers (tools, resources, prompts), the stdio transport, and the initialize handshake. Include one sequence-diagram slide of the three-message handshake between client and server, one short TypeScript slide showing a minimal tool registered with the MCP SDK, and finish with a quiz. ``` ![Scrimba Explain composer: a Markdown file attached as a chip below the prompt box.](https://scrimbaguide.tech/img/blog/how-to-use-scrimba-explain-prompts-and-teaching-styles/explain-composer-markdown-attachment-chip.webp) *The attached file shows as a chip under the prompt. Dropping a file onto the box works; the paperclip opens your system file picker.* The result, [Building Your First MCP Server](https://scrimba.com/explain/guide02qftck7g) (1:17), tracked the file closely. The sequence diagram labelled the three messages `initialize`, `result` and `notifications/initialized`, as my document did. The `server.ts` slide used the real `@modelcontextprotocol/sdk` and `zod` imports, and the narration repeated my note that a stdio server must log to `console.error`, never `console.log`. It skipped the section on Streamable HTTP, which the prompt had not asked about. So an attachment does two things. It grounds the explainer in your text instead of the model's general knowledge, and it lets you point the prompt at parts of the document. Attach your own notes before an exam, or a README you have to onboard onto, and ask for the three things you keep forgetting. ## Playlists as a mini curriculum Toggle the playlist icon next to the visibility picker and Explain plans a series of explainers on one topic, then builds them lesson by lesson ([docs.scrimba.com/explain/playlists](https://docs.scrimba.com/explain/playlists?via=u42d4986)). Each lesson gets its own URL, and the playlist inherits whatever style and visibility you chose. I asked for three lessons on context engineering, the subject of Arsala Khan's [Learn Context Engineering](https://scrimbaguide.tech/docs/courses/ai/context-engineering/), a one-hour, 15-scrim course that trims and summarises a chat app's message history on the Vercel AI SDK. ``` Context engineering for AI agents, for a developer who has built one chatbot and is now adding tools and memory. Three lessons, each under 2 minutes. Lesson 1: what actually goes into the context window on every call (system prompt, message history, tool schemas, tool results) and why it fills up faster than you expect; include one diagram slide. Lesson 2: retrieval versus long context, when to fetch a few relevant chunks and when to send everything. Lesson 3: managing memory and tool results, summarising old history, truncating large tool output, and keeping state outside the window. Use short JavaScript examples where code helps, and end lesson 3 with a quiz. ``` ![Scrimba Explain playlist: the lesson player beside a panel listing the three lesson titles.](https://scrimbaguide.tech/img/blog/how-to-use-scrimba-explain-prompts-and-teaching-styles/explain-playlist-context-engineering-three-lessons.webp) *The playlist panel sits beside the first lesson. The three lengths add up to the 3 min label, and each lesson opens at its own URL.* The three lessons came out at 1:15, 1:14 and 0:51 ([lesson 1](https://scrimba.com/explain/guide0j3tt3irh), [lesson 2](https://scrimba.com/explain/guide0ih5ernr6), [lesson 3](https://scrimba.com/explain/guide0bnbt17e2)), and the whole set finished building in under 40 seconds. Each lesson stayed on its assigned sub-topic and referred back to the previous one. Lesson 1's `payload.json` slide shows the system prompt, tool schemas and message history competing for the same token budget, which is the point of the course. Two things did not follow the prompt. Every lesson ended with a quiz, although I asked for one on lesson 3 only. And lesson 2's example hard-coded `model: "gpt-4o"`, which nobody asked for. Neither is wrong, but a playlist follows its own plan more than a single explainer does, so keep per-lesson instructions short. ## Go deeper and follow-ups cost one explainer each Two buttons keep the conversation going after an explainer ends. Go deeper sits in the player's top corner (or the right-click menu). It pauses playback and opens a card for the current slide, then spawns a standalone explainer that uses the lesson and that slide as context ([docs.scrimba.com/explain/going-deeper](https://docs.scrimba.com/explain/going-deeper?via=u42d4986)). Follow-ups are the suggested questions on the end card, plus a free-text box. Both create a new explainer, and both count against your allowance ([docs.scrimba.com/explain/limits-and-plans](https://docs.scrimba.com/explain/limits-and-plans?via=u42d4986)). A free account gets 10 explainers for the life of the account; Pro gets 100 a month. So a single question, two follow-ups and one Go deeper is four of a free account's ten. Redo slide and Regenerate narration, both in the player's cog menu, are free. ## The seven styles, as the menu describes them The chevron next to the Explain button lists seven styles with a tagline each. Quoting the menu: - Explain: "Simple words, small steps" (the default) - Standard: "Clear, well-rounded teaching" - Per: "Plain language, concrete examples" - Tom: "Tom Chant, in his own voice" - LOL: "Funny and sarcastic, still accurate" - Professor: "Maximum depth, down to the bytes" - TLDR: "A few slides, straight to the point" Per and Tom are Scrimba's founder and one of its teachers. Among the styles, TLDR is the only one that never ends with a quiz (overviews, own-code tasks and Chrome extension page explainers skip it too). Styles apply on the web only; explainers made from ChatGPT or an MCP agent are written by that model, so the picker does not exist there. ## Portrait output and the mobile toggle The cog menu on your own explainer has a Vertical view toggle, next to Show captions and Show watermark, for reformatting slides to portrait. Scrimba's mobile app is not released; there is a waitlist, and the docs say your web explainers will appear in it at launch ([docs.scrimba.com/explain/mobile-app](https://docs.scrimba.com/explain/mobile-app?via=u42d4986)). Until then a phone gets the web player. ## Prompts that waste your quota With 10 explainers on a free account, the expensive mistakes are the ones that make you regenerate. - A prompt with no audience sentence. Scrimba's docs say this is the line most people skip; I did not test the omission myself, but a second explainer to fix the pitch is the likely cost. - Running the same prompt across styles to compare them. I have done that for you above; the differences are small. - Asking for "everything about X". My seven explainers ran between 0:51 and 1:28, so a broad topic gets a shallow pass. Narrow it or use a playlist. - Chaining follow-ups instead of writing the follow-up question into the original prompt. - Regenerating to fix one slide or a mispronounced word. Redo slide and Regenerate narration are free. If you are working through Scrimba's [AI Engineer path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/), this is where these prompts pay off: get stuck in Arsala Khan's 36-scrim [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) (the Gift Genie build) or Bob Ziroll's 31-scrim [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) (the hand-written ReAct loop), and run an explainer on the one lesson you failed to follow, with the course's own variable names in the audience sentence. ## Ten free explainers is enough to learn the prompt shape A free Scrimba account gets 10 explainers for life. Write the audience sentence first, and one of them is usually enough. [Try Scrimba free](https://scrimba.com/?via=u42d4986) ## References - [Scrimba Docs, Writing a good prompt](https://docs.scrimba.com/explain/prompting?via=u42d4986): topic, audience and slide types, art styles, pushing depth past the style. - [Scrimba Docs, Teaching styles](https://docs.scrimba.com/explain/teaching-styles?via=u42d4986): the seven styles and that they are web-only. - [Scrimba Docs, Attaching documents](https://docs.scrimba.com/explain/attaching-documents?via=u42d4986): accepted file types and the paste-to-attachment behaviour. - [Scrimba Docs, Playlists](https://docs.scrimba.com/explain/playlists?via=u42d4986): one URL per lesson, inherited style and visibility. - [Scrimba Docs, Going deeper](https://docs.scrimba.com/explain/going-deeper?via=u42d4986): what the button does and that it consumes allowance. - [Scrimba Docs, Limits and plans](https://docs.scrimba.com/explain/limits-and-plans?via=u42d4986): 10 explainers on Free, 100 a month on Pro, what counts. - [Scrimba Docs, Mobile app](https://docs.scrimba.com/explain/mobile-app?via=u42d4986): waitlist only at the time of writing. - The seven explainers generated for this post, all Public: [A1](https://scrimba.com/explain/guide0niu04ksn), [A2](https://scrimba.com/explain/guide0sp3ljm85), [A3](https://scrimba.com/explain/guide050741s62), [B](https://scrimba.com/explain/guide02qftck7g), the playlist ([1](https://scrimba.com/explain/guide0j3tt3irh), [2](https://scrimba.com/explain/guide0ih5ernr6), [3](https://scrimba.com/explain/guide0bnbt17e2)). **Q: What should a Scrimba Explain prompt contain?** Three things: the topic, the audience (who it is for and what they already know), and the slides you want, such as one diagram, one code slide and a quiz. Scrimba's docs call the audience line the sentence most people leave out. I did not test a prompt without one. On the same RAG prompt, though, switching teaching styles changed less than I expected, so the prompt text is where the depth gets set. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/prompting?via=u42d4986) **Q: Which Scrimba Explain teaching style should I use?** Start with Standard. It produced the most accurate code of the three I compared on the same RAG prompt, and it was the same length as Professor. Use Explain when you want an analogy and shorter sentences, and TLDR when you want the core idea in a few slides without a quiz. **Q: Is the Professor style deeper?** Not noticeably, at least for a detailed prompt. On the same RAG prompt, Professor ran 1:26 against Standard's 1:28 with the same slide types and overlapping headings. It added one worked example of embedding vectors and nothing else Standard lacked. If you want depth, ask for it in the prompt. **Q: Can I upload a PDF or a Markdown file to Scrimba Explain?** Yes. The composer accepts code files, text and Markdown, PDFs, images and Jupyter notebooks, by drag and drop or the paperclip button. Pasting a large block of text also turns it into an attachment. The docs state no size limit and say nothing about how uploads are stored, so do not attach anything confidential. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/attaching-documents?via=u42d4986) **Q: Do follow-ups and Go deeper use up my explainers?** Yes. Each follow-up question and each Go deeper click creates a new explainer and counts against your allowance: 10 for life on a free account, 100 a month on Pro. Redo slide and Regenerate narration are free. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/limits-and-plans?via=u42d4986) **Q: How do playlists work in Scrimba Explain?** Toggle the playlist icon in the composer and describe the lessons you want. Explain plans the series and builds each lesson as its own explainer with its own URL. My three-lesson context engineering playlist finished in under 40 seconds, but every lesson got a quiz even though I asked for one on the last lesson only. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/playlists?via=u42d4986) **Q: Can I watch explainers in portrait on my phone?** The cog menu on your own explainer has a Vertical view toggle. Scrimba's mobile app is waitlist-only at the time of writing, and the docs say your web explainers will appear in it once it launches. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/mobile-app?via=u42d4986) --- # Is React still worth learning in 2026? What the data says Source: https://scrimbaguide.tech/blog/is-react-still-worth-learning-2026/ Yes, React is still worth learning in 2026, and the jobs data is not close. The qualifier that matters is which React: the version worth your months is React 19 with hooks and the App Router, not the class-component React most older free tutorials still teach. Pick the wrong tutorial and you learn 2021 React. Pick the right one and you learn the React that gets interviews. ## Is React still worth learning in 2026? Yes. React is still the safest single thing a frontend beginner can learn in 2026: it has more open roles and more learning material than any other UI library, and its hiring demand has held flat while newer frameworks trade small slices of attention. The React that gets you hired is not the React a three-year-old playlist teaches, and that gap is the real subject of this article. As of June 2026, the most recent Stack Overflow survey, the 2025 edition, puts React at 44.7% usage, behind only Node.js at 48.7%. Node.js is a runtime, not a UI framework, so it sits on top of a combined list of web technologies. Among the UI frameworks, React leads by a wide margin, ahead of Angular at 18.2% and Vue at 17.6%. That is the latest published data: Stack Overflow only opened its 2026 survey on June 23, 2026, so there are no 2026 numbers yet. Whether a junior can still get hired in this market at all is a separate question, and I answer it in [the 2026 junior developer job market](https://scrimbaguide.tech/blog/junior-developer-job-market-2026/). The door is open. This piece is about what to walk through it with. ## What the 2026 jobs data actually shows React still produces more job listings and stronger pay than any directly comparable frontend skill, and none of the trend lines have turned down. As of June 2026, US job boards list React and Next.js roles in the thousands. Indeed shows several thousand React-developer openings, and Glassdoor lists around 5,800. Those counts drift daily, so treat the shape, thousands of live roles, as the signal rather than any single number. Pay holds up too. As of June 2026, ZipRecruiter puts the average US React developer salary at about $129,000 a year, with most salaries falling between $106,000 at the 25th percentile and $157,000 at the 75th. The longer arc agrees: as of June 2026, the US Bureau of Labor Statistics projects employment of web developers and digital designers to grow 7% from 2024 to 2034, much faster than the average for all occupations, with about 14,500 openings a year. A framework that is supposedly dying does not sit on top of the usage charts, the salary bands, and a positive ten-year projection at the same time. ## Why the React-is-dead takes keep recycling React is not dying. The "React is dead" takes recur because React's public API changes often enough that, every couple of years, a large batch of tutorials goes stale all at once, and a stale tutorial feels like a stale framework. It happened with hooks. When function components and hooks arrived in 2019, a wall of class-component tutorials became the wrong way to start, and "React is too confusing now" takes followed. It is happening again with Server Components and the App Router, which make parts of the hooks-era, client-only tutorial canon look incomplete. So "React is dead" is almost always "the React I learned got old," restated as a prediction. The library underneath is the same one leading the usage charts. What expired is a generation of teaching material, and that is a content problem you solve by choosing a current course, not by abandoning React. ## The modern React stack: React 19 and the App Router The stack worth learning in 2026 is React 19, function components with hooks, and increasingly Next.js with the App Router. React 19 shipped as stable on December 5, 2024, bringing Actions, the useActionState and useOptimistic hooks, the use() API, and stable Server Components, according to the official react.dev release post. These are not fringe features. As of June 2026, about 48% of daily React users in the State of React 2025 survey are already on React 19, with another 41% or so still on React 18, so the version you should learn is the one most working React developers have already moved to. On the framework side, as of June 2026 the App Router, which renders Server Components by default, is the way new Next.js apps are built, while the older Pages Router is no longer the path Next.js recommends for new projects. That guidance is Next.js's own, not a survey headline. One practical note before you buy a Next.js course: the App Router builds on React you should already know, so it is the last layer, not the first. Most of the 2026 stack is also written in TypeScript, so learn [TypeScript alongside JavaScript](https://scrimbaguide.tech/blog/best-typescript-courses/) rather than saving it for later. ## Do I need to learn React Server Components in 2026? Server Components are the most divisive part of modern React, and that split is the single best reason not to start there. As of June 2026, Server Components and Server Functions land as the third and fourth most-disliked new features in the State of React 2025 survey. Not the single most disliked, but high enough that two of the marquee additions to modern React are openly unpopular with the developers using them. The friction is real and specific. As of June 2026, the most-cited pain point developers raise about Server Components is Context API incompatibility, the top issue in that survey at 59 mentions, because patterns that worked fine in client-side React break or need rethinking on the server. And adoption is still early: as of June 2026, fewer than half of developers have tried React Server Components in new projects, roughly 45% by one reading of the survey. The State of React 2025 numbers come from a Devographics survey of 3,760 respondents collected between November 2025 and January 2026, with a sample that skews toward more plugged-in developers, so the real-world tried-it rate across all developers is probably lower than what the survey shows. My take: Server Components are the right long-term direction for React and the wrong starting point for a beginner. They solve problems you only feel once you have shipped a client-side app and watched it get slow. Start with them and you are learning the cure for a pain you have never had, on the least-loved, least-stable corner of the API. Learn client-side React 19 first. Add Server Components when you reach Next.js and they have a problem to solve. ## Who should still learn React in 2026 (and who shouldn't) [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) if you want a frontend or fullstack web job, want to fish in the largest hiring pool, or know you will end up in Next.js. That covers most people reading a "should I learn React" post, and for them the answer is a clean yes. React is one skill inside a broader frontend toolkit, so once it clicks, widen out using the rest of the [frontend developer skills for 2026](https://scrimbaguide.tech/blog/frontend-developer-skills-2026/) rather than collecting React APIs in isolation. Some readers should skip React for now. If you have not learned JavaScript yet, React will feel like memorizing magic words, because React is JavaScript and assumes you can already write it: learn the language first, then the library. If you are aiming at pure backend or data work, React is optional. And if all you need is a small static marketing site, React is more machinery than the job calls for. For everyone whose target job description has the word React in it, which is most frontend and fullstack postings, the [React course catalog](https://scrimbaguide.tech/docs/courses/react/) is the thing to point yourself at. ## How to learn modern React in 2026 without drowning Learn it in order: solid JavaScript first, then client-side React 19 with hooks, then a real project, then Next.js and the App Router last. The order is the difference between modern React feeling learnable and feeling like drowning, because each layer assumes the one before it. The drowning usually comes from the source, not the subject. A random YouTube playlist from 2021 teaches class components, lifecycle methods, and patterns React itself now steers you away from, and a beginner cannot tell which parts have expired. You end up learning two Reacts at once, the dated one in the video and the current one in the docs, and blame yourself for the confusion. [Scrimba versus YouTube for learning to code](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-youtube/) covers why unsequenced video fails at exactly this. The fix is a path where someone has already removed the 2021 detours and put the lessons in an order that builds. I reviewed [Scrimba's Learn React course](https://scrimbaguide.tech/docs/courses/react/learn-react/) with a Pro account this year. Bob Ziroll teaches it hooks-first across about 15 hours and six projects, and two of the six are worth a portfolio slot on their own: Chef Claude, a recipe app that calls Anthropic's Claude API, and Assembly: Endgame, a hangman game with two accessibility passes. You edit his code directly in the browser and watch the component re-render next to it, the same loop you use on the job: read a component, change it, see what breaks, fix it. Every section and both capstones are free, so the interactive format costs you nothing to test. If it clicks, [the Frontend Developer Path](https://scrimba.com/frontend-path-c0j?via=u42d4986) sequences that same React course into an 81.6-hour, MDN-endorsed track through HTML, CSS, JavaScript, TypeScript, and React (see current [Scrimba pricing](https://scrimbaguide.tech/docs/pricing/) for the path). The exact module order to follow, from JavaScript fundamentals through React 19, is laid out in [the Scrimba React learning path](https://scrimbaguide.tech/blog/scrimba-react-learning-path/), so you are not guessing what comes next. ## React vs Vue, Svelte, and Angular in 2026 React wins on jobs, Vue and Svelte win on developer happiness, and Angular holds the enterprise. If your goal is the widest range of employment, React is the pragmatic pick. If your goal is one specific company, follow that company's job posting instead of the chart. The usage gap is large. As of June 2026, the Stack Overflow 2025 survey has React at 44.7%, Angular at 18.2%, and Vue at 17.6%, with Svelte smaller still but consistently near the top on satisfaction. None of the alternatives are bad technology, and a developer who knows Vue or Svelte well is employable. There are just fewer doors, and for a beginner optimizing for a first job, door count matters more than elegance. React is also one of the frameworks MDN teaches in its own client-side frameworks tutorials, alongside Vue, Angular, and Svelte, though MDN is explicit that it does not endorse any single one. That neutral, documented teaching track is a quiet point in React's favor: the reference site the whole industry trusts treats it as worth knowing. ## Does AI make learning React pointless? No. AI makes reading React a more valuable skill, not a redundant one, because it generates a blend of current and outdated React and cannot tell you which is which. Ask a coding assistant for a component and you will get a mix: sometimes clean React 19, sometimes a class component, sometimes a Server Component pattern dropped into a spot where a client component belongs. As of June 2026, the API is changing fast enough that the training data behind these tools is part new, part stale, and the model has no reliable sense of which. That puts the judgment back on you. The developer who knows modern React reads the generated component, spots the deprecated hook or the wrong rendering boundary, and fixes it in seconds. The one who never learned it ships whatever compiled. AI has not removed the reason to learn React. It has moved the reward from typing the component to being the person who can tell whether the component is right. So here is the concrete next step, and you can do it today. Open the React docs at react.dev, build one small component that fetches and displays data with the use() API, then pull up any 2021 React tutorial and count how little of it still applies. That gap between the two is the exact version of React worth spending your 2026 on. ## Frequently asked questions Is React still worth learning in 2026? Yes. As of June 2026, React is the most-used UI framework in the Stack Overflow 2025 Developer Survey, and US job boards list React and Next.js roles in the thousands. The catch is that the React worth learning now is React 19 with hooks and the App Router, not the class-component code most older free tutorials still teach. Is React dead in 2026? No. As of June 2026, React leads every other UI framework in usage in the Stack Overflow 2025 survey, ZipRecruiter puts the average US React developer salary at $129,348 a year, and the BLS projects web developer and digital designer jobs to grow 7% through 2034. The is-React-dead posts recycle every year because the API keeps shifting, not because demand is dropping. Should I learn React or Next.js in 2026? Learn plain React first, then Next.js. React teaches you components, state, and hooks, which Next.js assumes you already know. Once you can build a small React app without a framework, move to Next.js and its App Router, which as of June 2026 is the default way new Next.js projects are built. Do I need to learn React Server Components in 2026? Eventually yes, but not on day one. As of June 2026, fewer than half of developers have tried React Server Components in new projects, and they rank among the most-disliked new features in the State of React 2025 survey. Server Components are the right long-term direction and the wrong starting point for a beginner. Learn client-side React 19 first, then add Server Components when you reach Next.js. Which React should a beginner learn in 2026? Learn function components, hooks like useState and useEffect, and React 19 features such as Actions and the use() API. Skip class components except to recognize them in old code. As of June 2026, about 48% of daily React users in the State of React 2025 survey are already on React 19, so learning the older patterns first means relearning later. Does AI make learning React pointless? No. AI can generate React components, but it produces a mix of modern and outdated patterns and cannot tell you which one fits your app. As of June 2026 you still need to read React well enough to catch the deprecated hook or the Server Component dropped where a client component belongs. AI makes reading React a more valuable skill, because someone has to judge whether the generated code is correct. ## Learn modern React in order Skip the 2021 tutorials. Scrimba teaches current React through real projects. Start free. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # Is software engineering dead in 2026? What hiring data says Source: https://scrimbaguide.tech/blog/is-software-engineering-dead-2026/ No, software engineering is not dead in 2026. The hiring data published this month says the field held up better than almost any other job function, with one real catch: the entry-level door shrank by roughly two thirds, and people keep mistaking that smaller door for a dying field. If you are deciding whether to start coding right now and the doom headlines rattled you, that distinction is the whole story, because it changes where you aim, not whether you begin. ## Is software engineering dead in 2026? Short answer: no No. The clearest signal is hiring, not headlines, and the freshest hiring numbers came out six days ago. SignalFire's State of Talent Report, covered by TechCrunch on June 24, 2026, found that while total hiring across the largest tech companies is running about 25% below its 2019 level, engineering hiring is down just 11%. Engineers also take a bigger slice of who gets hired than they did before the AI wave: 55% of all new hires in 2025, up from 46% in 2019. Hold those two facts next to the "AI killed coding" narrative and they do not fit it. If software engineering were being automated away, engineering would be the function shrinking fastest. Instead it is holding up best. The doom story is real about one group of people, which I get to below. It is wrong about the field. ## What SignalFire's June 2026 talent report actually measured It measured a specific, US-skewed slice of the market, not the whole economy. SignalFire's numbers come from 12 of the largest tech companies (Alphabet, Meta, Apple, Amazon, Microsoft, Netflix, Nvidia, Tesla, Uber, Airbnb, Block, and Stripe) plus a separate look at early-stage startups, so they are big-tech-weighted and US-skewed. SignalFire is a venture firm that tracks employment moves across its dataset, and it benchmarks 2025 hiring against a 2019 baseline, before both the pandemic boom and the AI wave. That scope cuts two ways. It covers the part of the market that hires the most engineers and sets the tone for everyone else, so it is a fair read on the center of gravity. It also leaves a lot out: small agencies, government work, and most non-US markets, where the picture can run warmer or colder. Treat it as the best available read on big tech and venture-backed startups, not a global census. ## The number that breaks the doom narrative The single figure that does the most damage to the "engineering is over" story is the 11%. Total hiring at those 12 companies fell about 25% from 2019, but engineering hiring fell only 11%, less than half as much as the average function. Engineering was the most resilient role in the dataset, not the most exposed. Two more numbers point the same way. Engineers made up 55% of all new hires at those companies in 2025, up from 46% in 2019, so as overall hiring cooled the cuts fell harder on non-engineering roles. And at early-stage startups, engineering hiring actually rose: they brought on 7% more engineers in 2025 than in 2019. The youngest, most AI-native companies, the ones with every reason to swap engineers for tools if it were possible, hired more of them. ## Why AI made engineers harder to cut The reason engineering held up is the opposite of the one the headlines assume. AI did not make engineers redundant; it made each one more productive, which created more engineering work, not less. As SignalFire's head of research, Asher Bantock, put it to TechCrunch in June 2026, engineers are "suddenly a lot more productive, and there's endless work for them to do." That is an old economic pattern. When a tool makes a kind of work cheaper, demand for that work often goes up, because more of it becomes worth doing. Faster, cheaper engineering means more features, more products, and more small companies that can afford to ship software at all, and every bit of that still needs engineers to steer it. Bantock was blunt about the gap between the story and the data, noting that the stated reason for many layoffs "is consistently AI," while "what we're seeing on the ground is a little inconsistent with that." "Resilient" gets oversold online, and down 11% is still down. Big-tech engineering hiring did not grow; it shrank less than everything around it. The strong version of the good news lives at early-stage startups, where engineering hiring genuinely rose. At the giants, engineers were the last people companies wanted to cut, not the group they went on a hiring spree for. ## Are entry-level developer jobs gone in 2026? Entry-level hiring is where the real damage shows up, and it is severe. The overall numbers hide a sharp split by experience: SignalFire's 2026 report shows entry-level hiring down roughly 65% at the big tech companies and about 76% at early-stage startups, both compared with 2019. CIO Dive, summarizing the same report, framed the big-tech figure the same way: hiring of workers with under one year of experience "shrunk by 65% from its 2019 baseline." The field is healthy and the front door is about two thirds narrower than it was. Both things are true, and conflating them is where most of the panic comes from. AI made experienced engineers more productive, which is exactly why companies feel less need to hire juniors for the work that AI now speeds up. The squeeze is not "no jobs." It is "fewer of the first jobs, and more people competing for each one." I dug into how that reshapes the junior market in [the junior developer job market in 2026](https://scrimbaguide.tech/blog/junior-developer-job-market-2026/), and into whether AI is actually taking those roles in [can AI replace junior developers](https://scrimbaguide.tech/blog/can-ai-replace-junior-developers-2026/). The short version: the entry rung is thinner, not gone, and how you approach it matters more than it used to. ## Is the job market growing or shrinking long term? It is growing. The U.S. Bureau of Labor Statistics projects employment of software developers, QA analysts, and testers to grow 10% from 2025 to 2035, much faster than the average for all occupations. About 106,100 openings for that group are projected each year on average over the decade, counting both new roles and people leaving the field. Pay stays high: the median for software developers specifically was $135,980 a year in May 2025 (QA analysts and testers earn less, a median of $104,300). Government projections are not promises, and that 10% is a ten-year average that smooths over a rough 2024 to 2026 stretch. It is still a useful counterweight to a single year of hiring data. The cyclical story (a cold 2025, a brutal entry-level squeeze) sits inside a structural story (a decade of above-average growth). If you are choosing a field to spend years on, the decade matters more than the quarter. ## What AI actually changed about the job AI did not delete the job; it moved the center of it from writing code to checking it. Most working developers now use these tools and trust them only so far. In the Stack Overflow 2025 Developer Survey, published in July 2025 and still the latest edition since the 2026 survey only opened on June 23, 2026, 84% of developers said they use or plan to use AI tools, and 51% of professionals use them daily. Yet more developers distrust the accuracy of that output (46%) than trust it (33%), and only about 3% highly trust it. That gap is the job now. Someone has to read the generated code and decide whether it is correct, and that someone is a person who understands the code. The skill that pays is judgment, and judgment is exactly what runs short when juniors are scarce. It is also why "just let AI write it" is not a free pass: a METR randomized trial published in July 2025 (arXiv:2507.09089) found 16 experienced open-source developers working in repositories they already knew well took 19% longer on tasks when using early-2025 AI tools, even though they felt about 20% faster. You cannot judge output you cannot read. For a beginner, the takeaway is specific. The version of the job that is hiring rewards people who can build something real and explain why it works, which is the spine of a route like Scrimba's [frontend developer path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/): 81.6 hours across 13 modules, and you write and run code in nearly every one of the 1,493 scrims instead of watching someone else type. Write the code, run it, fix what breaks, repeat until you can defend it. ## So is it still worth starting to code, or building for the web, in 2026? Yes, for most people asking, and here is who it fits best. | Your situation | Worth it if... | Watch out for | | --- | --- | --- | | Career switcher | You can put in real weekly hours for months, not weeks | Certificates with no deploys behind them | | Student | You want paid freelance work while you are still in school | Trivia instead of projects | | Already employed | You want to move into a product team from where you sit now | Studying with nothing to demo internally | | Bootcamp-curious | You need a hard deadline to actually finish | A loan-sized bet with no runway if the timeline slips | The official outlook backs this up, checked again today. BLS still projects employment of software developers, QA analysts, and testers to grow 10% from 2025 to 2035, with about 106,100 openings a year and a median $135,980 (May 2025), the same figures cited above. Web development sits on a flatter curve: a median $90,930 for web developers alone (May 2024, the same figure I use in [developer specialization and the 2026 job market](https://scrimbaguide.tech/blog/developer-specialization-job-market-2026/)), because the web-facing slice of the field pays less than backend-leaning software roles even as both keep hiring. On "AI will take web dev": copilots cut the time spent on boilerplate and searching for syntax, not the need to make architecture calls and reason about edge cases, accessibility, and security. That is the same judgment gap this piece already traced to the entry-level squeeze above; the tool moved the job from typing to reviewing, it did not remove it. Whether you have started too late, or which path fits a career change, are their own debates, and I work through them in [best Scrimba courses for career changers](https://scrimbaguide.tech/blog/best-scrimba-courses-career-changers/); I am not going to relitigate them here. The point that belongs in this piece is narrower: the field, web-facing corner included, is hiring, it pays well, and the part that got harder is the first job, not the career. So the real question is not "should I start," it is "how do I start so I land on the open side of that smaller door." The answer the data keeps pointing at is proof of work. When there are more applicants than junior seats, a screening manager filters on who can show working code, not on who finished the longest list of tutorials. You do not need a degree to produce that proof; I learned to code through the project-based 42 Network, and I make the no-degree case in [getting a developer job without a degree](https://scrimbaguide.tech/blog/developer-job-without-degree-2026/). What you need is things you built. ## Where to start if you're deciding right now Start by building a couple of small projects you can put in front of a hiring manager, and learn whatever each project forces you to learn. Project first, curriculum second, is the order that survives a tight entry market, because it produces the exact artifact that gets you past the filter. I broke down which projects actually move a hiring decision in [portfolio projects that get you hired](https://scrimbaguide.tech/blog/portfolio-projects-get-hired-2026/), and the broader job-hunt mechanics in [how to get your first developer job in 2026](https://scrimbaguide.tech/blog/how-to-get-first-developer-job-2026/). For the learning itself, pick a format that has you writing and running code from the first lesson instead of watching someone else type. That is the same read-it-and-fix-it loop the modern job is built on, so practicing the format is practicing the work. Scrimba's courses run in the browser and make you edit and run the instructor's code as you go, and several of them are free to start, which is the low-risk way to find out whether that style clicks before you pay for anything. The [frontend developer path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) closes with a 5.1-hour, 73-scrim Getting Hired module on the exact proof-of-work problem this piece is about: building a portfolio, cleaning up GitHub and LinkedIn, and drilling interview questions. Scrimba Pro is a low monthly subscription if you want that full path (see current [Scrimba pricing](https://scrimbaguide.tech/docs/pricing/)). I point there and not at a video playlist because a tight entry market rewards people who can build, and you only learn to build by building. So here is the concrete next step, and you can take it this week: pick one small project (a weather page, a habit tracker, a tip calculator), build it end to end, and push the code somewhere a stranger can read it. That single artifact does more for a 2026 job hunt than another certificate. The door is smaller. It is not closed. ## Frequently asked questions Is software engineering dead in 2026? No. SignalFire's State of Talent Report 2026, covered by TechCrunch on June 24, 2026, found engineering hiring at the largest tech companies down only 11% from 2019 while total hiring fell about 25%, and engineers rose to 55% of 2025 new hires. The field is not dying. What shrank is the entry-level door. Will AI replace software engineers in 2026? Not so far. The same report shows engineering hiring held up better than every other function, and SignalFire's head of research told TechCrunch the on-the-ground data is inconsistent with the AI-layoff story. AI made each engineer more productive, which raised demand for engineering work rather than removing it. Are entry-level developer jobs gone in 2026? No, but they got much harder to land. SignalFire's 2026 report shows entry-level hiring (workers with under one year of experience) down roughly 65% at the big tech companies and about 76% at early-stage startups versus 2019. Entry-level roles still exist; there are just fewer of them and more applicants per opening. Is the software engineering job market growing or shrinking in 2026? Long term it is growing. The U.S. Bureau of Labor Statistics projects employment of software developers, QA analysts, and testers to grow 10% from 2025 to 2035, much faster than average, with about 106,100 openings a year. The 2026 squeeze is concentrated at the entry level, not across the whole field. Is it still worth learning to code in 2026? Yes, if you aim at proof of work rather than a credential. The field is hiring and pays well, with median pay for software developers at $135,980 in May 2025 per the BLS, but the entry door now rewards people who can show shipped projects. Start by building, not by collecting certificates. How do you get hired as an entry-level developer when the door is smaller? Build real projects and make them easy to verify. With roughly two thirds fewer junior openings, the people who get through are the ones who can point to working code they wrote and explain why it works. A projects-first path beats a lecture-first one for getting to that point. ## Prove you can ship The entry bar is higher now, so build real projects. Start with Scrimba's free courses. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # JavaScript Projects for Beginners (2026): 20 Ranked Ideas Source: https://scrimbaguide.tech/blog/javascript-projects-for-beginners-2026/ Beginner JavaScript projects, todo lists, timers, quiz flows, API readers, teach more than tutorials because you type the logic, hit the edge cases, and deploy something real. The 20 below are ranked by what they train, state, fetch, deploy discipline, so a portfolio site outranks a calculator even though the calculator is simpler to build. The Scrimba specifics below (module names, scrim counts, instructors) come from our own course reviews, each written after going through the course inside a Pro account. Full sourcing is in `data/courses.json` and the linked review pages. Use it alongside [/docs/courses/javascript/](https://scrimbaguide.tech/docs/courses/javascript/) and [/docs/courses/react/](https://scrimbaguide.tech/docs/courses/react/) on this site, and our [escape tutorial hell](https://scrimbaguide.tech/docs/how-it-works/tutorial-hell/) playbook when projects stall. ## How we ranked "learning value" Higher rank means more transfer to job tasks: persistence, async UX, security instincts, deploy discipline. "Beginner" and "intermediate" describe complexity, not quality. A narrow, well-scoped intermediate build still counts. ## Master table (all 20 projects) | Rank | Project | What it teaches | Difficulty | Scrimba-aligned starting point | | --- | --- | --- | --- | --- | | 1 | Portfolio site | Deploy pipeline, content hierarchy, performance basics | Beginner | [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) capstones + [Deploying with Netlify](https://scrimbaguide.tech/docs/courses/javascript/deploying-with-netlify/) | | 2 | Expense tracker | CRUD, validation, totals, persistence | Intermediate | [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) projects lane | | 3 | Weather app | `fetch`, loading/error UI, env vars | Beginner | Vanilla fetch drills in [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) | | 4 | To-do list | State, filters, localStorage | Beginner | Classic path milestone | | 5 | Flashcard app | Data modeling, study flows | Intermediate | [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) after JS core | | 6 | Pomodoro timer | Timers, pause/resume, edge cases | Beginner | DOM + interval practice | | 7 | Quiz app | Routing or steps, scoring | Beginner | Component/state patterns | | 8 | Markdown previewer | Parsing, sanitization mindset | Intermediate | [Markdown course](https://scrimbaguide.tech/docs/courses/javascript/markdown/) | | 9 | GitHub profile viewer | REST JSON, empty states | Intermediate | API shaping | | 10 | Image search (Unsplash) | Keys, quotas, query UX | Intermediate | API + images | | 11 | Recipe finder | Nested data, filters | Intermediate | JSON transforms | | 12 | URL shortener | IDs, collisions, optional serverless | Intermediate | Backend-light variant OK | | 13 | Mini social feed | Lists, optimistic UI | Intermediate | [React Challenges](https://scrimbaguide.tech/docs/courses/react/react-challenges/) | | 14 | Typing speed test | Keyboard events, timing | Beginner | Input handling | | 15 | Budgeting tool | Forms, categories, exports | Intermediate | Data entry UX | | 16 | Password generator | Randomness, clipboard | Beginner | Crypto `getRandomValues` | | 17 | Color palette generator | Color spaces, contrast | Beginner | [Color tool in vanilla JS](https://scrimbaguide.tech/docs/courses/javascript/) | | 18 | Calculator | Parsing, keyboard UX | Beginner | State machine lite | | 19 | Random quote generator | `fetch`, retries | Beginner | Smallest useful API app | | 20 | Drum machine | Audio timing | Intermediate | Media APIs | ## Group A, pure JavaScript (no framework) Build these first if you still pause on events, DOM updates, and `async/await`. - Calculator: forces you to handle bad input and reset state without React masking the data flow. [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/)'s blackjack game module runs the same muscle for 2.7 hours across 55 scrims, holding card state and betting logic by hand before you ever meet `useState`. - Random quote generator: minimal surface area, good for fetch-and-render repetition. - Typing speed test: timer literacy and focus edge cases. - Password generator: a practical Web Crypto or `getRandomValues` introduction. - Color palette generator: HSL and RGB intuition and contrast thinking for real UIs. - Drum machine: makes timing bugs obvious, and it is fun if you like tactile feedback loops. Anchor your reading with [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/), Per Borgen's free 9.4-hour course, and keep [how to escape tutorial hell](https://scrimbaguide.tech/docs/how-it-works/tutorial-hell/) open when you want to peek at a solution without copying it. ## Group B, React projects (after JS clicks) Move here once you can scaffold `createRoot`, `useState`, and `useEffect` on purpose, not from muscle memory left over from a video. - To-do list (React version): still the best state-lifting teaching tool. - Flashcard app: good for component boundaries (card, deck, session summary). [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/)'s Tenzies capstone builds a similar boundary problem, a `Die` component feeding a parent's win check, in 19 scrims. - Quiz app: practice controlled flows and derived state. The same course's Assembly: Endgame capstone (28 scrims) is a hangman clone that tracks guessed letters, disables the keyboard on game over, and picks a new word on reset, the closest Scrimba analog to a quiz engine. - Mini social feed: list rendering, keys, and empty states that feel social. - Markdown previewer: pairs React with sanitized-HTML habits. [Dylan C. Israel's Markdown course](https://scrimbaguide.tech/docs/courses/javascript/markdown/) covers the syntax itself in 26 scrims if you need the reference before wiring up a renderer. Deep links: [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/), taught by Bob Ziroll across six projects and about 15 hours, [React Router](https://scrimbaguide.tech/docs/courses/react/react-router/), and the [Movie Search App](https://scrimbaguide.tech/docs/courses/react/a-react-project-movie-search-app/) project write-up. ## Group C, API and integration projects These still need vanilla `fetch` clarity even when the UI is React. Debugging a network request is a career-long skill. - Weather app: the classic loading, success, failure triad. - GitHub profile viewer: pagination and schema drift (API fields change on you). - Image search: rate limits and lazy loading stress your layout skills. - Recipe finder: nested attributes train defensive rendering with `?.` patterns. [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/)'s own recipe app, the Chef Claude project inside the React State module, does exactly this: 58 scrims that end by wiring a form to the Claude API and rendering whatever comes back. - URL shortener: even a mock-persistence version teaches ID design, and a small serverless function is a bonus. James Q Quick's [Movie Search App](https://scrimbaguide.tech/docs/courses/react/a-react-project-movie-search-app/) project is the closest single Scrimba build to this whole group: 13 scrims fetching from The Movie Database API, handling loading and empty states, and rendering a results grid. ## Making Scrimba course projects "yours" Scrimba's courses already include working versions of a movie search app, a recipe finder, dice and word games, and several React builds. Submitting one of them unchanged is the hiring mistake: a reviewer who has seen the course recognizes the layout in ten seconds. Fork the idea, not the file. Re-theme it, add one real data source of your own, add one feature the course never asked for (an analytics event, a keyboard shortcut, a contrast fix), and rewrite the README as if you were handing the repo to a teammate who has never seen the course. Scrimba's paths bundle these projects with the surrounding curriculum; see [current plans](https://scrimba.com/our-pricing?via=u42d4986) for what that costs where you live. ## Suggested 4-week rotation (10–12 hours/week) | Week | Focus | Deliverable | | --- | --- | --- | | 1 | Vanilla DOM + fetch | Quote generator + weather skeleton | | 2 | State + persistence | Todo or expense MVP | | 3 | React port | Rebuild week 2 app with components | | 4 | Polish + deploy | README, Lighthouse pass, mobile check | ## Comparison: practice project vs portfolio project | Dimension | Practice project | Portfolio project | | --- | --- | --- | | Goal | Reps and recall | Proof for employers | | Scope | Small, disposable | Narrow but polished | | README | Bullet notes | Setup, decisions, tradeoffs | | Deploy | Optional | Expected | ## Tie-ins across this site - Roadmap timing: [How long it takes to learn web development](https://scrimbaguide.tech/blog/how-long-to-learn-web-development-2026/) - Career context: [Is software engineering dead in 2026?](https://scrimbaguide.tech/blog/is-software-engineering-dead-2026/) - Format comparison: [Scrimba vs freeCodeCamp](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-freecodecamp/) ## Bottom line Pick one project from the master table, finish it in a single vertical slice per sitting, and deploy it before you move on. Twenty small builds are training. Three customized ones, with a README and a live URL, are the signal a hiring manager actually reads. ## Want guided versions of these builds? Scrimba's courses include projects like these with a written brief and a recorded solution. Customize them so your GitHub tells your story, not the instructor's. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # Junior Developer Job Market in 2026: Brutal Truths Source: https://scrimbaguide.tech/blog/junior-developer-job-market-2026/ Junior developer hiring is down sharply since the 2021 peak, and a typical US tech job search now runs five to six months across 200-plus applications. Developers still get hired: the ones who add AI skills, ship real projects, and target startups and agencies over frozen enterprise pipelines, where junior hiring hasn't stalled the way it has at large companies. ## Who this is for You are entering the market as a junior developer and want a realistic read on 2026 hiring, the skills that still differentiate candidates, and how long the timeline actually takes. ## Current state as of 2026-09-28 | Signal | Latest reading | Source, dated | | --- | --- | --- | | US software development postings on Indeed | Index 77.32 on 2026-09-18 (2020-02-01 = 100), about 23% below pre-pandemic | [FRED series IHLIDXUSTPSOFTDEVE](https://fred.stlouisfed.org/series/IHLIDXUSTPSOFTDEVE), Indeed Hiring Lab data | | All US job postings on Indeed | Index 103.5 on 2026-09-18, about 3% above pre-pandemic, +0.7% year over year, the first positive annual reading in almost four years | [Indeed Hiring Lab snapshot](https://hiringlab.indeed.com/2026/09/24/us-labor-market-snapshot-september-2026/), 2026-09-24 | | Who the software rebound is for | 71% of the rise in software development postings from May 2025 to May 2026 came from senior roles, and 37% came from postings with AI in the title | [Indeed Hiring Lab](https://hiringlab.indeed.com/2026/07/08/ai-and-job-postings-from-destruction-to-creation/), 2026-07-08 | | Tech layoffs | 2026 had already passed all of 2025 (122,606 people at 278 companies) by 2026-08-06; AI was cited in 33% of 2026 layoff events, up from 1% in 2024 | [Futurism](https://futurism.com/future-society/2026-tech-layoffs-surpass-2025), 2026-08-14; [Crunchbase News](https://news.crunchbase.com/layoffs/2026-layoff-numbers-rise-ai-shift-orcl-meta-amzn/), 2026-09-25 | | UK entry-level hiring intent | 19% of 1,500 UK business leaders are reducing entry-level recruitment, and 42% of those cite wider AI use | [Open University Business Barometer 2026](https://business.open.ac.uk/business-barometer), via [CNBC](https://www.cnbc.com/2026/09/23/ai-workplace-graduate-entry-level-junior-hiring.html), 2026-09-23 | Indeed's Hiring Lab puts it bluntly: tech postings "remain depressed despite improving from last year's lows." ## Update log ### 2026-09-24: Indeed says overall postings turned positive, but software is still about 23% below 2020 Indeed's Job Postings Index for all US roles hit 103.5 on 2026-09-18, about 3% above the February 2020 baseline and up 0.7% year over year, the first positive annual reading in almost four years ([Indeed Hiring Lab](https://hiringlab.indeed.com/2026/09/24/us-labor-market-snapshot-september-2026/), 2026-09-24). Software development did not share the recovery: the same-day software index sat at 77.32, about 23% below baseline ([FRED IHLIDXUSTPSOFTDEVE](https://fred.stlouisfed.org/series/IHLIDXUSTPSOFTDEVE)). And the gains that exist skew toward people who already have a job: Hiring Lab found that 71% of the rise in software postings between May 2025 and May 2026 came from senior roles, and 37% came from postings that name AI in the title ([Indeed Hiring Lab](https://hiringlab.indeed.com/2026/07/08/ai-and-job-postings-from-destruction-to-creation/), 2026-07-08). The recovery is real, but it is going to candidates with experience and AI skills first, which is exactly why learning AI skills and building projects that solve real problems still matter more than a clean React resume. ### 2026-09-23: UK employers say AI is shrinking entry-level intake The Open University's Business Barometer 2026, a survey of 1,500 UK business leaders, found 51% saying AI is changing how they hire, 19% reducing entry-level recruitment, and 42% of that group blaming AI adoption specifically ([Open University](https://business.open.ac.uk/business-barometer), reported by [CNBC](https://www.cnbc.com/2026/09/23/ai-workplace-graduate-entry-level-junior-hiring.html), 2026-09-23). SHL's Lucy Beaumont described the shift to CNBC as a move from a hiring "pyramid" to a "diamond," with more headcount concentrated at mid-level and fewer training-ground seats at the bottom. This is UK data, but the pattern matches the US postings above: fewer "trainee" openings, so a [portfolio that proves you can already ship](https://scrimbaguide.tech/blog/portfolio-projects-get-hired-2026/) matters more than a certificate. ### 2026-09-25: 2026 tech layoffs have already passed the 2025 total Tech layoffs in 2026 had already exceeded all of 2025 (122,606 people across 278 companies) by 2026-08-06, and the total kept climbing to 126,305 by mid-August ([Futurism](https://futurism.com/future-society/2026-tech-layoffs-surpass-2025), 2026-08-14). Layoffs.fyi founder Roger Lee told Crunchbase News that AI was cited in 33% of 2026 layoff events, up from just 1% in 2024, but added there has been "little evidence that AI is actually replacing the work of the human employees let go" ([Crunchbase News](https://news.crunchbase.com/layoffs/2026-layoff-numbers-rise-ai-shift-orcl-meta-amzn/), 2026-09-25). For a junior, this matters because you are now competing with laid-off mid-level engineers for the same postings, which is why targeting startups, agencies and non-tech companies over frozen enterprise pipelines still beats a generic job-board search. ## How bad is the 2026 junior job market, really? Entry-level hiring has dropped in many regions compared to pre-pandemic levels, and a smaller share of tech hires now go to new graduates than a few years ago. The average job search for a US tech role runs 5-6 months and takes 200+ applications. Time-to-hire has stretched too: candidates report drawn-out, multi-stage processes that used to close in weeks. Those numbers are real. For the mid-2026 picture, [software engineering itself held up while the entry-level door narrowed](https://scrimbaguide.tech/blog/is-software-engineering-dead-2026/). ## Why is junior hiring down in 2026? ### AI automation of junior tasks Many of the tasks traditionally assigned to junior developers, writing boilerplate, basic CRUD operations, simple bug fixes, can now be handled by AI coding assistants. This has reduced some employers' perceived need for junior hires. ### Post-pandemic market correction The 2020-2022 hiring boom led to over-hiring. Companies corrected in 2023-2025 with layoffs and tighter budgets, and many haven't returned to previous hiring volumes for entry-level roles. ### Senior shortage creates an ironic problem Here's the paradox: many employers report a persistent shortage of experienced senior developers. But instead of hiring juniors to train, many companies are offering higher salaries to poach seniors from competitors. This creates a market where experienced developers are in extreme demand while juniors struggle. ## Is it still worth learning to code in 2026? Yes. Four reasons hold up even in a slow market: - The developer shortage is real. The market needs more developers; the problem is companies want experienced ones first. Every senior developer was once a junior, so companies will have to start hiring and training juniors again. - AI skills are a differentiator. Most bootcamp graduates can build a React app. Few can build one that calls an LLM API, retrieves your own data, or hands a task to an agent. Scrimba's [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) runs 11.4 hours across nine modules and has you build a ReAct agent by hand, wire up a RAG search over your own data, and deploy a Node app to Render, the kind of portfolio piece that separates you from the React-app crowd. - The salary upside is significant. Even in a competitive market, developer salaries remain strong. Entry-level roles start around $65,000-$80,000 in most US markets. - Remote work expands your options. You're not limited to your local market. Remote-first companies hire globally, multiplying your opportunities. ## How do junior developers stand out in 2026? ### 1. Learn AI skills (most juniors don't) This is the single biggest differentiator available to you right now. Adding AI engineering skills to your frontend toolkit sets you apart from most junior candidates, who stop at React. What to learn: - How to call LLM APIs (OpenAI, Claude, Mistral) - Building AI-powered features (chatbots, search, content generation) - RAG (Retrieval-Augmented Generation) for context-aware AI apps - AI agents that can use tools and take actions Scrimba's [AI courses](https://scrimbaguide.tech/docs/courses/ai/) cover all of this. The [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) is specifically designed for web developers adding AI skills. ### 2. Build projects that solve real problems Generic portfolio projects (todo apps, weather widgets, calculator clones) blend into the crowd. Instead, build projects that: - Solve a real problem for yourself or someone you know - Use a public API to fetch and display real data - Include AI features (even simple ones like summarization or chat) - Look production-ready with responsive design and error handling See our [portfolio project ideas for 2026](https://scrimbaguide.tech/blog/portfolio-projects-get-hired-2026/) for specific examples. ### 3. Target the right companies Not all companies have frozen junior hiring. Focus on: - Startups (20-100 employees): Often more willing to invest in juniors. They can't afford $250K seniors. - Agencies and consultancies: High turnover means constant need for new talent. - Companies with "AI initiatives": If a company is building AI features, they need developers who can implement them. - Non-tech companies with tech teams: Banks, retailers, healthcare companies, less glamorous but steady demand. ### 4. Network strategically In 2026, networking beats job boards. Many positions are filled before they're ever posted publicly. - Join the [Scrimba Discord](https://scrimbaguide.tech/docs/help/community-and-events/): 55,000+ members, many of whom are working developers who share opportunities. - Contribute to open source: Even small contributions put your name in front of engineering teams. - Attend local meetups and conferences: Face-to-face connections convert to referrals. - Use LinkedIn actively: Post about your learning journey. Comment on developer posts. Engage with hiring managers' content. ### 5. Prepare obsessively for interviews When you do get an interview, you need to be ready. The typical 2026 frontend interview includes: - Recruiter screen - Coding assessment (often take-home) - 1-2 technical conversations (React, JavaScript, system design basics) - Behavioral round Scrimba has specific courses for this. Treasure Porth's [JavaScript Interview Challenges](https://scrimbaguide.tech/docs/courses/javascript/javascript-interview-challenges/) drills 28 coding challenges across 2.3 hours, each followed by a worked solution, from FizzBuzz to an emoji slot machine built with `fetch`. Cassidy Williams' [React Interview Questions](https://scrimbaguide.tech/docs/courses/react/react-interview-questions/) turns 41 minutes of question-and-answer scrims into a mock interview, including one live exercise converting a class component to hooks. Dylan Israel's [Frontend Interview Tips](https://scrimbaguide.tech/docs/courses/javascript/frontend-interview-tips/) pairs 14 technical-screen answers with a resume, LinkedIn, and GitHub teardown. See our complete [interview prep guide](https://scrimbaguide.tech/blog/frontend-interview-prep-scrimba/) for a 4-week study plan. ## How long does it take to land a junior developer job? Plan for 8 to 12 months from zero to employed: | Phase | Duration | What You're Doing | | --- | --- | --- | | Learning | 4-6 months | Complete a [Scrimba career path](https://scrimbaguide.tech/docs/paths/) | | Portfolio building | 1-2 months | Build 3 strong projects (overlap with learning) | | Job search | 3-6 months | Apply, network, interview, iterate | | Total | 8-12 months | From zero to employed | This is longer than the "learn to code in 3 months" promises you see online. But it's realistic. Some people do it faster (see the [Scrimba success stories](https://scrimbaguide.tech/blog/scrimba-success-stories/) of 3-6 month timelines), but plan for the longer end. ## The bottom line The 2026 junior market is tough but not impossible. Developers who combine strong fundamentals, AI skills, impressive projects, and strategic networking are still getting hired. The key is going in with realistic expectations and a solid plan. Start with a structured learning path, build real projects, and don't give up when the job search gets hard. The developers who persist are the ones who land the job. If you are starting from zero, our [Frontend Developer Path review](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) shows what a structured route to a first junior role covers. ## Frequently asked questions **Q: Is it still worth learning to code in 2026?** Yes. The junior market is competitive but developers are still getting hired. AI skills, strong portfolios, and networking differentiate candidates. Entry-level salaries in many US markets remain competitive. The key is realistic expectations and persistence. **Q: How long does it take to get a first developer job?** Plan for 8-12 months total: 4-6 months of learning, 1-2 months building a portfolio, and 3-6 months of job search. Some people land roles faster; plan for the longer end to avoid frustration. **Q: What skills make junior candidates stand out?** AI integration (LLM APIs, RAG, agents), projects that solve real problems, and networking. Most juniors have React and JavaScript, adding AI and demonstrating initiative through projects sets you apart. ## Ready to start learning? Get full access to all Scrimba courses, paths, and community with Scrimba Pro. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # What to learn to code this summer 2026: a 9-week plan Source: https://scrimbaguide.tech/blog/learn-to-code-summer-2026/ What to learn to code this summer 2026: learn one track, not five, and build toward two small projects you can deploy by the end of August. For a beginner starting from zero this summer, that means HTML and CSS, then JavaScript, then a little React, in that order, with a real calendar attached. This plan runs from Monday, June 29 to Sunday, August 30, 2026, and the goal is to leave you project-capable, not job-ready: able to build and ship a small app and explain how it works. ## What to learn to code this summer 2026 (the short answer) Learn front-end web development, in one straight line: HTML and CSS, then JavaScript, then enough React to ship a small app. That sequence gives a beginner the fastest path to seeing real results, because the browser shows you what your code does the moment you save the file. The mistake I see every June is treating "learn to code" as a shopping trip. People spend week one on Python, week two on a JavaScript playlist, week three watching a Rust intro because someone said it was the future, and by August they have touched four languages and built nothing. One language, one track, two projects. That is the strategy, and the dated weeks below are how you execute it. ## Why summer is the best window a beginner gets Summer hands you the one thing learning to code actually needs and the rest of the year keeps stealing: a block of uninterrupted daily time. School is out, work often slows, and a couple of hours after breakfast or before dinner is realistic in a way it never is in October. That matters because most developers did not learn in a classroom. In the 2025 Stack Overflow Developer Survey, the latest published edition, online and self-directed resources dominate how people learn to code: technical documentation at 67.8%, other online resources at 58.7%, and video at 50%, while only 16.6% point to school or university and 5.2% to a coding bootcamp. Teaching yourself is not the disadvantage it sounds like; it is what most working developers actually did. The effort is worth pointing somewhere real, and the demand side holds up. The BLS projects 7% growth for web developers and digital designers from 2024 to 2034, faster than the average for all jobs (BLS Occupational Outlook Handbook). The entry door looked grim a year ago, but it is opening back up: NACE's Spring 2026 update revised projected hiring for the college Class of 2026 up to plus 5.6%, after an earlier projection of just 1.6% growth (NACE Job Outlook 2026 Spring Update, April 2026). None of that gets you hired by September. It does mean a summer spent learning is a bet on a field that is still growing. ## Pick one track, not five Pick JavaScript, and ignore every other language until at least September. For a from-zero learner who wants to watch their code do something visible this summer, JavaScript wins on feedback speed: it runs in the browser with zero setup, so the gap between writing a line and seeing it work is seconds, not an install guide. It also happens to be the language most developers actually use. JavaScript was still the most-used language among all developers in 2025, at 66% in the Stack Overflow survey. That figure is about survey respondents across the whole field. If you look at GitHub instead, the picture shifts: TypeScript became the most-used language there in 2025, edging past Python and JavaScript by monthly contributors (GitHub Octoverse 2025). TypeScript is just JavaScript with types bolted on, so learning JavaScript first is the on-ramp to both. Python is GitHub's data and AI leader, and it is a fine first language if your goal is specifically data or machine learning. It is the wrong starting point if you want to build something you can click on by August. So here is the opinion I will defend: do not start with AI or machine learning this summer unless you can already build a small app. The math and the tooling will bury a beginner before they ship anything, and shipping is the whole point. If you want to test the interactive, edit-the-code style before committing your summer to it, the [best free Scrimba courses](https://scrimbaguide.tech/blog/best-free-scrimba-courses/) are a no-cost way to start this week and find out whether front-end clicks for you. ## The nine-week plan, week by week (June 29 to August 30) Nine weeks, two projects, with a tenth week held back as a buffer. The plan runs Monday, June 29 to Sunday, August 30, 2026, which is 63 days, nine weeks exactly. The week of August 31 to September 6 is deliberately empty: it is your buffer and catch-up week, so even if a vacation or a bad week throws you off, you still finish before Labor Day on Monday, September 7. | Week (2026) | Focus | Milestone by Sunday | | --- | --- | --- | | Week 1 (Jun 29 to Jul 5) | HTML structure and semantic tags | A static page with real content, unstyled | | Week 2 (Jul 6 to Jul 12) | CSS layout: Flexbox, Grid, responsive design | The same page, styled and mobile-friendly | | Week 3 (Jul 13 to Jul 19) | JavaScript basics: variables, functions, arrays, objects | Small scripts that transform and log data | | Week 4 (Jul 20 to Jul 26) | The DOM: events, selecting elements, updating the page | A page that reacts to clicks and typing | | Week 5 (Jul 27 to Aug 2) | fetch, async/await, and reading an API | A page that loads and shows live data | | Week 6 (Aug 3 to Aug 9) | Project one: a vanilla JavaScript app | Deployed project one with a README | | Week 7 (Aug 10 to Aug 16) | React: components, props, state | UI pieces rebuilt as components | | Week 8 (Aug 17 to Aug 23) | React: hooks, lists, forms, routing | A multi-view React app running locally | | Week 9 (Aug 24 to Aug 30) | Project two: a React app, deployed | Two projects live on the internet | | Buffer (Aug 31 to Sep 6) | Catch up, polish, write READMEs | Both projects clean before Labor Day | Read the milestone column as the contract, not the focus column. Watching three hours of React content is not week seven done. A component rebuilt from memory and rendering on the screen is. If you want this same shape stretched across a longer runway than one summer, I lay out the year version in [how long it takes to learn web development](https://scrimbaguide.tech/blog/how-long-to-learn-web-development-2026/). ## How many hours a day do you actually need? Plan on roughly 1.75 to 2 hours a day, most days. Across the full nine weeks, 63 days, that works out to about 110 to 126 hours total, which is enough to learn the basics and ship two small projects, and not enough to pretend you are suddenly senior. That estimate comes from the calendar, not a study, so treat it as a planning number. The shape of those hours matters more than the total. A short daily session beats one long weekend cram, which is the principle behind behavior scientist BJ Fogg's Tiny Habits method: consistency beats intensity, because a small thing you do every day actually sticks. Three two-hour sessions on a Saturday feel productive and teach you less than thirty minutes a day for six days, because coding is recall, and recall fades fast between Saturdays. If holding a daily streak is the part you struggle with, I wrote a practical version of this in [building a coding habit](https://scrimbaguide.tech/blog/build-coding-habit-scrimba/). Miss a day, do not miss two. That is the only rule that protects the whole plan. ## The summer traps: vacations, motivation dips, and tutorial hell Three things kill summer coding plans, and all three are predictable: the vacation, the week-five motivation dip, and tutorial hell. Each has a built-in answer in this schedule. Vacations are why the buffer week exists. If you are away the week of August 10, that is fine: do what you can, then use August 31 to September 6 to reclaim the React week you lost. The buffer is not slack to burn early, it is insurance you draw on once. The motivation dip almost always lands around week five, when the novelty is gone and the syntax errors are not. The fix is the project in week six. Knowing you are about to build something real, not watch more lessons, is what pulls most people through the slump. The third trap is the worst because it disguises itself as progress: tutorial hell, where you finish course after course and still cannot open a blank file and start. The cure is the milestone column above, which forces you to build with the editor open and the video closed. I go deeper on the escape in [how to escape tutorial hell](https://scrimbaguide.tech/docs/how-it-works/tutorial-hell/). ## Only have August? The compressed four-week version If you are reading this in late July and only have August, run a shorter plan and ship one project instead of two. Four weeks at the same daily pace gets you a real, if narrower, result. Spend week one on HTML and CSS, weeks two and three on JavaScript and the DOM, and week four building and deploying one small vanilla JavaScript project. Drop React entirely; it is the part that needs the most runway, and a beginner who half-learns it in three days learns it wrong. A single finished, deployed project beats two abandoned half-projects every time. Less calendar means fewer projects, not lower-quality ones. For a realistic read on what different time budgets actually produce, see [how long it takes to learn web development](https://scrimbaguide.tech/blog/how-long-to-learn-web-development-2026/). ## What to build, and why a shipped project beats a certificate Build two small things that are yours and live on a public URL, not a copy of the instructor's demo. A shipped project is the only artifact from this summer that a future employer, or you in September, can actually click on and judge. Good first projects are small and finishable: a personal site with real content, a weather or quote app that pulls from a free API, a to-do or budget tracker that saves data. The bar is not clever, it is finished and deployed, with a README that explains what it does and one feature you can talk through. A certificate says you watched the material. A deployed project says you can build, and that gap is the whole reason to spend a summer this way. When you are ready to think about which projects carry weight with hiring managers, [portfolio projects that get you hired](https://scrimbaguide.tech/blog/portfolio-projects-get-hired-2026/) is the next read. ## Where Scrimba fits this summer plan If you would rather have this sequence handed to you in order than assemble it from scattered tutorials, that is the gap a structured platform fills. The plan above mirrors the structure of the Scrimba study plan: HTML and CSS, then JavaScript, then React, with small projects threaded through the weeks instead of saved for the end. You can see how that path is laid out in the [Scrimba study plan](https://scrimbaguide.tech/docs/paths/study-plan/), and if you are torn between the front-end and full-stack routes, [frontend vs fullstack paths](https://scrimbaguide.tech/docs/paths/) compares them before you commit a summer to one. Scrimba is built around editing real code in the browser, not just watching it, and the two courses that map onto parts of this plan are both free. Per Borgen's [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) runs 9.4 hours across eight modules and has you build a passenger counter, a blackjack game, a Chrome extension, and a mobile app, which lines up with weeks three, four, and six: JavaScript basics, DOM events, and a vanilla-JS project. It does not cover weeks one and two (HTML and CSS) or week five (fetch and async/await); the course stays with synchronous JavaScript and never reaches promises or async code. Bob Ziroll's [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) picks up at 15.1 hours across six projects, including a Chef Claude recipe app and two capstone games, and lines up with weeks seven and eight. Run either one for free and find out whether the interactive format works for you before you commit a summer to it. If it does and you want the full sequenced path plus projects, Scrimba Pro is a low monthly subscription (see current [Scrimba pricing](https://scrimbaguide.tech/docs/pricing/)). The hard part of this plan is the sequence. A structured path removes the "what do I learn next" decision, so your two hours go into writing code instead of planning to write code. Now do the one thing that makes any of this real. Open a calendar, block two hours for your next free morning, and write "HTML" in that first slot. A plan with a start date is a plan. A plan without one is a bookmark. ## Frequently asked questions What should I learn to code this summer 2026? Start with one track and one language. For a beginner who wants visible results fast, that means HTML and CSS, then JavaScript, then a little React, building toward two small projects you actually deploy. JavaScript was the most-used language among all developers in 2025 at 66% in the Stack Overflow survey, and it runs in the browser, so you see what your code does immediately. Skip the urge to sample five languages. Can you learn to code in one summer? You can become project-capable, not job-ready, in one focused summer. Nine weeks at roughly two hours a day is about 110 to 126 hours, which is enough to build and ship two small projects from scratch. It is not enough to walk into a senior interview, and anyone promising that is selling something. Treat the summer as the on-ramp, not the finish line. Should I learn JavaScript or Python first in 2026? For a from-zero beginner who wants to see results this summer, learn JavaScript first. It runs in the browser with no setup, so the feedback loop is immediate, and it was still the most-used language among all developers at 66% in the 2025 Stack Overflow survey. Python is the better first language if your goal is data or AI work specifically, but do not start there expecting to build AI tools in one summer. How many hours a day do I need to learn to code this summer? Plan on about 1.75 to 2 hours a day, most days. A short daily session beats a long weekend cram, which is the core idea behind BJ Fogg's Tiny Habits method: consistency beats intensity. Two hours a day for nine weeks lands around 110 to 126 hours total, enough to finish the plan with a buffer week before Labor Day. Is it too late to start coding in July or August 2026? No. If you start in late June you get the full nine-week plan, finishing the week of August 30, with the week of August 31 to September 6 as a buffer before Labor Day on September 7. If you only have August, run the compressed four-week version: HTML and CSS plus JavaScript, and ship one project instead of two. Less calendar means fewer projects, not lower-quality ones. Will one summer of coding make me job-ready? No. One summer makes you project-capable: you can build and deploy a small app and explain how it works. Getting hired takes more practice past the summer, though the entry market is improving; NACE revised projected Class of 2026 hiring up to plus 5.6% in its Spring 2026 update. Treat the two shipped projects as the start of a portfolio, not proof you are done. ## Follow a structured plan A guided path keeps a summer of learning from drifting into tutorial hell. Start with Scrimba's free courses. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # MCP explained for JavaScript developers (after the 2026-07-28 spec) Source: https://scrimbaguide.tech/blog/mcp-for-javascript-developers/ MCP is a JSON-RPC 2.0 standard that lets an AI app (the host) call your code through a server exposing tools, resources and prompts, a typed API the model discovers at runtime. The [2026-07-28 revision](https://modelcontextprotocol.io/specification/2026-07-28/changelog) made it stateless: no `initialize` handshake, no sessions. If you know APIs, the model and a STDIO server still hold; new code uses SDK v2. ## What changed on 2026-07-28 If you have not met MCP at all yet, [How to build your first AI agent](https://scrimbaguide.tech/blog/how-to-build-ai-agent-beginners-2026/) already covers the plain-English version and the November 2024 launch history; this post assumes that part and goes straight to building a server and to what changed on 2026-07-28. On [2026-07-28](https://blog.modelcontextprotocol.io/posts/2026-07-28/), the MCP maintainers shipped a new [specification revision](https://modelcontextprotocol.io/specification/2026-07-28/changelog), the first since 2025-11-25. Their own framing: MCP moved from "a bidirectional stateful protocol into a request/response stateless protocol," something they call one of the most requested changes from developers chasing better reliability and scale. | Before (2025-11-25) | After (2026-07-28) | Does a beginner notice? | | --- | --- | --- | | `initialize` / `initialized` handshake opens every connection | Removed. Every request carries `protocolVersion` and `clientCapabilities` in `_meta`; servers must implement `server/discover` | No, if you use an SDK. The SDK builds the `_meta` block for you | | Streamable HTTP sessions tracked by an `Mcp-Session-Id` header | Removed. Cross-call state uses server-minted handles passed back as ordinary tool arguments | Only if you wrote your own session logic by hand | | Server-initiated requests (elicitation, sampling, roots) block on an open stream | Multi Round-Trip Requests: a result comes back as `resultType: "input_required"`, and the client retries with the answer | No, unless your tool needs mid-call user input | | `GET` endpoint plus `resources/subscribe` for change notifications | A single `subscriptions/listen` stream, opt-in per notification type | Only if you subscribe to live updates | | Streamable HTTP POSTs were unlabeled JSON bodies | POSTs require `Mcp-Method` and `Mcp-Name` headers; list results carry `ttlMs` and `cacheScope` | No, this is plumbing for gateways and caches | | Roots, Sampling, Logging, the legacy HTTP+SSE transport, and Dynamic Client Registration were active | All deprecated, with at least a twelve-month support window; log to `stderr` on stdio instead of using the Logging feature | Only if your server used one of these | | Resource-not-found returned error `-32002` | Now `-32602` (Invalid Params), matching plain JSON-RPC | No | One line on auth, since it is easy to over-read: the spec also tightens OAuth issuer validation (RFC 9207) and nudges Dynamic Client Registration toward Client ID Metadata Documents. That is a server-operator concern, not something a learner writing a local STDIO server needs to touch. ## Does this change what you're learning? Verdict: no. Map MCP onto the client-server API you already know instead of learning it from zero. An MCP host is the AI app doing the talking (Claude Code, Claude Desktop, VS Code), and it spins up one MCP client per server it connects to. Your server is the program that answers. The data layer is [JSON-RPC 2.0](https://www.jsonrpc.org/) over a transport: STDIO for a local process, Streamable HTTP for a remote one. A tool is an action, close to a POST. A resource is read-only data, close to a GET. A prompt is a reusable template. The client discovers what a server offers by calling `tools/list`, then invokes one with `tools/call`, per [MCP's architecture docs](https://modelcontextprotocol.io/docs/learn/architecture). That mental model is exactly the same before and after 2026-07-28. What changed is the wiring underneath a couple of those pieces, and an SDK handles almost all of it for you. So, does a course or tutorial built before the new spec still apply? Yes, for the concepts and for a local STDIO server. What differs is the SDK version. The [TypeScript SDK v2](https://ts.sdk.modelcontextprotocol.io/v2/migration/upgrade-to-v2.html) shipped alongside the spec, published as `@modelcontextprotocol/server` 2.0.0 on 2026-07-27 (2.1.0 followed on 2026-09-23, the latest release as of 2026-09-28 per the npm registry). It replaced the monolithic `@modelcontextprotocol/sdk` package, whose v1 line is still getting patches too, most recently on 2026-09-23. The SDK's own [roadmap](https://raw.githubusercontent.com/modelcontextprotocol/typescript-sdk/main/ROADMAP.md) says plainly that "the v1.x branch continues to receive bug fixes and security updates for at least six months after the v2 release," so a v1 tutorial is not stale, just on an older package. v2 needs Node.js 20+ and `zod ^4.2.0`, and it drops the old variadic call in favour of a config object: `server.tool(name, description, schema, handler)` becomes `server.registerTool(name, { description, inputSchema }, handler)`. That is the one line that actually changes in most tutorials. And here is the detail that resolves the "is my old tutorial dead" worry completely. The SDK's own page on [supporting the 2026-07-28 revision](https://ts.sdk.modelcontextprotocol.io/v2/migration/support-2026-07-28) says "nothing in v2 puts a 2026-07-28 byte on the wire by default: a hand-constructed `Client` / `Server` / `McpServer` keeps speaking the 2025-era protocol it was written for." Plain `server.connect(new StdioServerTransport())` keeps talking the older wire format unless you opt into the new one with `serveStdio()` on stdio or `createMcpHandler()` over HTTP. So a server written the "old" way still works with today's hosts. The stateless wire format is something you choose, not something that broke under you. ## What to do: build a minimal MCP server in Node.js - `mkdir mcp-server && cd mcp-server && npm init -y`, then set `"type": "module"` in `package.json`. - `npm install @modelcontextprotocol/server zod` (v2 requires `zod ^4.2.0`). - Write `server.ts`: ``` import { McpServer } from '@modelcontextprotocol/server';import { StdioServerTransport } from '@modelcontextprotocol/server/stdio';import * as z from 'zod/v4';const server = new McpServer({ name: 'greeting-server', version: '1.0.0' });server.registerTool( 'greet', { description: 'Greet someone by name', inputSchema: z.object({ name: z.string() }), }, async ({ name }) => ({ content: [{ type: 'text', text: `Hello, ${name}!` }], }));async function main() { const transport = new StdioServerTransport(); await server.connect(transport);}main(); ``` This is the SDK's own minimal example, kept exactly as published. It speaks the 2025-era wire format by default; opting into the 2026-07-28 format on stdio means swapping the last two lines for the SDK's `serveStdio(() => buildServer())` helper, whose exact import path you should copy from the [migration docs](https://ts.sdk.modelcontextprotocol.io/v2/migration/support-2026-07-28) rather than guess, since the SDK's package layout changed with the 2026-07-28 spec update. - Log with `console.error`, never `console.log`, once your server does real work over stdio. Standard output is the protocol channel; anything you write to it corrupts the JSON-RPC stream. - Run it with `npx tsx server.ts`, then test it with `npx @modelcontextprotocol/inspector@latest`, pointing it at your server command. - Moving an existing v1 project: run `npx @modelcontextprotocol/codemod@latest v1-to-v2 .` at the package root. The codemod rewrites the SDK surface (imports, `tool()` to `registerTool()`) for you; it does not adopt the 2026-07-28 wire format, which stays a manual, opt-in step per the migration guide above. ## How do I learn MCP hands-on? I reviewed all 17 scrims of Scrimba's [Intro to Model Context Protocol (MCP)](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/) course with a Pro account: Maham Codes builds a weather MCP server in Node.js and TypeScript with one tool, one resource, a STDIO transport and three coding challenges. It pins `@modelcontextprotocol/sdk` 1.15 and the v1 `server.tool()` call, so the only line you would change for v2 is that call becoming `registerTool()`. Everything else, including the "log to stderr, not stdout" lesson, carries over. Start with the [free sample lessons](https://scrimba.com/intro-to-model-context-protocol-mcp-c0sake4uir?via=u42d4986) for a guided version of the build above. ## Bottom line Learn the model once, host, client, server, tools, resources, prompts, JSON-RPC over STDIO or HTTP. That does not change. Write new servers on SDK v2 with `registerTool()` and `zod ^4.2`. An older STDIO tutorial, including one pinned to SDK v1, is still a perfectly good place to start; it keeps working with today's hosts because the new wire format is opt-in, not automatic. Next step: build the six-step server above, then run it through the Inspector before you wire it into a host. **Q: Is MCP stateless now?** Yes, as of the 2026-07-28 specification revision. The initialize handshake and Streamable HTTP sessions are gone; every request carries its own protocol version and capabilities, so a server needs no shared connection state to answer it. **Q: Do I need TypeScript for MCP?** No. Plain JavaScript works fine; you just lose the compile-time checks. The official SDK is written in TypeScript and documented in TypeScript, which is why most examples, including the one above, use it, but nothing in the protocol requires it. ## Build your first MCP server with a guided course Scrimba's free intro scrims let you try the edit-the-code format before you pay for anything. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # 5 Portfolio Projects That Actually Get You Hired in 2026 Source: https://scrimbaguide.tech/blog/portfolio-projects-get-hired-2026/ Recruiters have seen a thousand todo apps. The five projects below get noticed because each one pairs a real API or AI feature with production polish: auth, error states, a live deploy. Start from a Scrimba solo project, then extend it past the original scope. I reviewed every course and project named here from inside Scrimba with a Pro account. ## What portfolio projects actually get you hired in 2026? Recruiters do not expect perfect code from a junior developer. They look for proof you can think like one: - Take a vague requirement and build something that works - Handle edge cases and error states, not just the happy path - Write code someone else could read - Ship a UI a real user would want to touch A tutorial clone fails all four tests. It proves you can follow instructions, not that you can solve a problem. The fix: take a Scrimba solo project as your starting point and extend it far beyond the original scope. | Project | Core tech | Time to build | Starting point | | --- | --- | --- | --- | | AI-powered content tool | React + LLM API | A weekend | [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) | | Extended solo project | React + auth + state | A weekend | [Movie Search App](https://scrimbaguide.tech/docs/courses/react/a-react-project-movie-search-app/) | | Real-time dashboard | React + public API + charts | A weekend | [CSS Grid](https://scrimbaguide.tech/docs/courses/css/css-grid/) | | Finance or productivity tool | React + Supabase | A weekend | [Supabase course](https://scrimbaguide.tech/docs/courses/backend/supabase/) | | Full-stack app with auth | Next.js + TypeScript + SQL | 1-2 weekends | [Fullstack Developer Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) | ## The 5 projects ### Project 1: AI-powered content tool What to build: A web app that uses an LLM API to transform, summarize, or generate content. A blog post outline generator, a code documentation writer, or a meeting notes summarizer all work. Tech stack: React + OpenAI/Claude API + Tailwind CSS Why it works: AI integration is the biggest differentiator for junior portfolios in 2026. Most candidates skip it. This project proves you can call an API, handle async state, and ship something people would actually use. Scrimba courses that help: [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) is Arsala Khan's 2.5-hour, 36-scrim course, and it builds the exact skill this project needs: it takes you from a first API call to a Node backend while building Gift Genie. Pair it with [Prompt Engineering for Web Developers](https://scrimbaguide.tech/docs/courses/ai/prompt-engineering-for-web-developers/) (Treasure Porth, 3.1 hours, 50 scrims, 11 ChatGPT challenges) to tighten the prompts, and build the UI in [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/), Bob Ziroll's free 15-hour course with six projects including Chef Claude on the Claude API. Make it stand out: Add conversation history, export to Markdown, and a "refine" button that improves the output iteratively. ### Project 2: Extended Scrimba solo project What to build: Take one of Scrimba's built-in solo projects, like the [Movie Search App](https://scrimbaguide.tech/docs/courses/react/a-react-project-movie-search-app/), and add three to five significant features. Example additions to the Movie Search App: user authentication with saved favorites, "Watched" versus "Want to Watch" lists with drag-and-drop sorting, genre-based recommendations, a dark/light theme toggle that respects system preference, and a layout that actually works on mobile. Why it works: Extending an existing codebase is what you do on a real job. Adding auth, state management, and responsive design in one project shows breadth a from-scratch clone cannot. Scrimba courses that help: the Movie Search App itself is James Q Quick's 56-minute, 13-scrim Pro project on React 16, with three challenges built in, a solid weekend base. Learn the hooks and routing patterns to extend it in [Advanced React](https://scrimbaguide.tech/docs/courses/react/advanced-react/) (18.8 hours across three teachers, builds VanLife and a Supabase dashboard), make it responsive with [Responsive Web Design](https://scrimbaguide.tech/docs/courses/css/responsive-web-design/) (Kevin Powell, 15 hours, 175 scrims, four sites built mobile-first), and add auth with [Firebase](https://scrimbaguide.tech/docs/courses/javascript/firebase/) (Rafid Hoda, 3.4 hours, 39 scrims, a mood journal with Google login, Firestore, and security rules). ### Project 3: Real-time dashboard What to build: A dashboard that displays live data from one or more public APIs. A cryptocurrency tracker, a GitHub activity dashboard, or a social media analytics view all work. Tech stack: React + REST APIs + a chart library (Recharts) + CSS Grid Why it works: A dashboard proves data fetching, state management, data visualization, and responsive layout in one project, and it looks good in a screenshot. Scrimba courses that help: [Advanced JavaScript](https://scrimbaguide.tech/docs/courses/javascript/advanced-javascript/) is Tom Chant's 9.8-hour, 156-scrim course with 94 challenges, and it covers the async patterns a live dashboard needs, from callback hell to generators. Lay the grid out with [CSS Grid](https://scrimbaguide.tech/docs/courses/css/css-grid/), Per Borgen's 63-minute, 17-scrim course that gets you to a 12-column layout by lesson four and includes a BBC News clone as its solo project. Make it stand out: Add auto-refresh, loading skeletons, error boundaries, and a filter/search system. ### Project 4: Personal finance or productivity tool What to build: A tool that solves a real problem in your own life. A budget tracker, an expense splitter, a workout logger, a meal planner, or a habit tracker all work. Why it works: Build something you actually use and it shows. The design decisions make sense, the features are practical, and you can talk about it honestly in an interview: "I built this because I needed it, and here's what I learned." Tech stack: React + Supabase (database and auth) + Tailwind CSS Scrimba courses that help: [the Supabase course](https://scrimbaguide.tech/docs/courses/backend/supabase/) is Jonathan Hill's free 4.8-hour, 49-scrim course and builds a React sales dashboard with auth, realtime updates, and row-level security, the exact backend this project needs. Learn the design principles in [UI Design Fundamentals](https://scrimbaguide.tech/docs/courses/css/ui-design-fundamentals/) (Gary Simon, free, 70 minutes, five CSS-only design challenges), then style it fast with [Tailwind CSS](https://scrimbaguide.tech/docs/courses/css/tailwind-css/) (Rachel Johnson, 2.2 hours, 33 scrims, a plant blog build and five challenges). Make it stand out: Add data export (CSV or PDF), charts showing trends over time, and deploy it to a real domain. Bonus points if you share it and get actual users. ### Project 5: Full-stack application with auth What to build: A complete web application with user registration, login, data storage, and CRUD operations. A job application tracker, a recipe sharing platform, or a team task board all work. Tech stack: Next.js + TypeScript + Supabase/PostgreSQL + Tailwind Why it works: A full-stack project demonstrates the broadest skill set. Building auth, database operations, and API routes end to end proves you understand how a web application actually works, not just its CSS. Scrimba courses that help: this is what the [Fullstack Developer Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) trains for across its 108.4 hours. Inside it, [Learn Next.js](https://scrimbaguide.tech/docs/courses/javascript/nextjs/) (8.5 hours, 123 scrims, two teachers) builds a PrintForge app on Next.js 15 and SQLite, [the TypeScript course](https://scrimbaguide.tech/docs/courses/typescript/) (Bob Ziroll, 4.2 hours, 79 lessons) covers TS in both React and Express, and [Learn SQL](https://scrimbaguide.tech/docs/courses/backend/sql/) (Gregor Thomson, free, 3.8 hours, 49 scrims, 62 challenges) teaches the database work on a vintage car dataset. Make it stand out: Deploy it live (Vercel is free), add proper error handling, loading states, and a polished UI. Write a clear README explaining the project's purpose and how to run it locally. ## How do you present these projects so recruiters notice? Building great projects is half the battle. Presenting them well is the other half. - Deploy everything. Every project belongs on a real URL. Vercel, Netlify, and Cloudflare Pages are all free. - Write a strong README. Cover what the project does, why you built it, the tech stack, how to run it locally, and what you'd improve next. - Record a demo. A 60-second screen recording of the app in action beats a wall of text every time. - Highlight the hard parts. In an interview, name the specific problem and the fix: "I struggled with X and solved it by researching Y" is exactly what a hiring manager wants to hear. A merged pull request on someone else's repo is the same signal from a different angle: proof you can read a real codebase and ship a change a maintainer accepted. [Hacktoberfest 2026](https://scrimbaguide.tech/blog/hacktoberfest-2026-first-pull-request/) is a low-pressure way to make your first one. ## How do Scrimba's own projects fit into this? Scrimba's career paths build multiple solo projects designed for a portfolio. The [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/), 81.6 hours and MDN-endorsed, and the [Fullstack Developer Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/), 108.4 hours, each stack projects at every stage so your skills compound. Do not submit the minimum. Take each solo project and add your own features, your own design choices, your own polish. That is what turns a course assignment into a genuine portfolio piece. ## Related reading - [How to Get Hired with Scrimba](https://scrimbaguide.tech/blog/how-to-get-first-developer-job-2026/), the complete job search blueprint - [Projects You'll Build on Scrimba](https://scrimbaguide.tech/blog/projects-youll-build-on-scrimba/), what's in the career paths - [Junior Developer Job Market 2026](https://scrimbaguide.tech/blog/junior-developer-job-market-2026/), why your portfolio matters more than ever - [Frontend Developer Skills 2026](https://scrimbaguide.tech/blog/frontend-developer-skills-2026/), what skills to showcase ## Ready to start learning? Get full access to all Scrimba courses, paths, and community with Scrimba Pro. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # 10 Projects You'll Build on Scrimba (2026) Source: https://scrimbaguide.tech/blog/projects-youll-build-on-scrimba/ Scrimba's Career Paths and Pro courses have you ship 10 portfolio-ready builds: a React Router rental site, two React capstone games, an AI support agent and a translation app, three vanilla-JS API projects, and two CSS layout builds. Below is what each one actually is, which course or path module it closes, and how long it takes. Most tutorials have you watch someone else type. Scrimba stops you every few minutes and makes you write the code yourself, so the project at the end of a module is code you wrote, not code you copied. Facts below come from the reviews on this site, each one written after going through the course inside a Pro account, plus module hours and lesson counts from Scrimba's own course pages. ## The "big three" capstones These are the flagship builds. Each one takes several hours and holds up as a portfolio piece on its own. ### 1. VanLife (React Router capstone) [Advanced React](https://scrimbaguide.tech/docs/courses/react/advanced-react/) closes its Routing module with VanLife, an Airbnb-style rental site for camper vans: ten-plus routes, three levels of nested navigation, search params, protected routes, and a mock API you later swap for Firestore. Bob Ziroll calls it "the most involved project that I have created for any React course." The module runs 6.4 hours across 86 scrims, and the later Supabase module goes further into the backend, with row-level security policies and a Postgres trigger you write yourself. ### 2. Quizzical (trivia app) [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) gates Quizzical, a trivia quiz app, behind Pro: it's the second Solo Project, sitting right after the Assembly: Endgame capstone. Like the course's other solo project, the Digital Business Card, it ships with a design file and a written spec and no walkthrough, so it works like a take-home test of what you just learned rather than another guided build. ### 3. Tenzies (dice game) [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) ends its first capstone section with Tenzies: roll ten dice, hold the ones you want, keep rolling until all ten match. You build a `Die` component, generate ten random dice, hold and reset state, then add lazy state initialization and two accessibility passes, including moving focus to the winning button with a ref. It's 86 minutes across 19 scrims, and confetti drops from `react-confetti` when you win. ## The AI projects (new for 2026) ### 4. AI support agent [Build a Support Agent with Vercel AI SDK](https://scrimbaguide.tech/docs/courses/ai/a-support-agent-with-vercel-ai-sdk/) is Mayo Oshin's Pro project course: 114 minutes across 23 scrims, ending in a Supabase-backed agent that classifies each question and routes it to retrieval, web search, or a direct answer. The Vercel AI SDK swaps in for a raw OpenAI client so you can change model providers without rewriting the app, and the longest scrim, Agentic Retrieval Routing, is where the classifier and the fallback logic come together. ### 5. Translator app [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) closes with PollyGlot, a translation app briefed by Per Borgen: type English text, pick a language, guess the translation yourself, then check it. Arsala Khan hands you a blank CSS file, a blank JavaScript file, and a near-empty HTML file, so you write the API call and the UI from scratch. The course itself is 2.5 hours across 36 scrims building Gift Genie, the gift-suggestion app that teaches streaming, tool calling, and a Node backend before PollyGlot. ## The "pure JavaScript" classics ### 6. Movie search app A vanilla-JS search form that calls an API and renders the results (posters, plots, no framework) is the kind of build the [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/)'s Working with APIs module trains: 7.6 hours across 96 lessons on `async`/`await`, `fetch`, and REST shapes. If you want the React version of the same idea instead, [Build a React Project: Movie Search App](https://scrimbaguide.tech/docs/courses/react/a-react-project-movie-search-app/) builds it in 56 minutes across 13 scrims against The Movie Database API. ### 7. Color scheme generator A palette tool that fetches colors from a public API and copies a hex code to your clipboard is another vanilla-JS rep from that same [Working with APIs module](https://scrimbaguide.tech/docs/paths/frontend-developer-path/): fetch, render JSON, and this time the Clipboard API too. ### 8. Mobile restaurant ordering app An UberEats-style menu, add items to a cart, calculate a total with event listeners and data attributes, sits in the range of what the path's [Essential JavaScript module](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) covers: 10.6 hours across 121 lessons on closures, array methods, and the patterns React assumes you already know. ## Design and layout projects ### 9. Learning Journal The [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/)'s Responsive Design module closes with "Solo Project: Learning Journal," a multi-page blog layout you deploy yourself, the kind of mobile-first, breakpoint-driven build the module trains. It's a path-only project: the standalone [Learn Responsive Web Design](https://scrimbaguide.tech/docs/courses/css/responsive-web-design/) course, taught by Kevin Powell across 15 hours, ends in a different build, a three-page company site with a slide-out mobile menu. ### 10. Digital Business Card [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) opens with this one: your first React component, styled from a design file, closing the Static Pages section (2.4 hours, 29 scrims) before the course moves on to data-driven props and state. ## Frequently Asked Questions **Q: Are these projects unique?** No, thousands of students build them. You MUST customize them to make them stand out. Change the colors, add a new feature (e.g., add a 'Dark Mode' to VanLife), or use a different API (e.g., make a 'Dog Search' instead of 'Movie Search'). **Q: Can I use these for commercial work?** The code is yours, but the design assets usually belong to Scrimba. It's best to use the *code logic* but swap out the images/branding for your own portfolio. ## Related Pages - [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) - [How to Get Hired](https://scrimbaguide.tech/blog/how-to-get-first-developer-job-2026/) - [Portfolio Projects That Get You Hired](https://scrimbaguide.tech/blog/portfolio-projects-get-hired-2026/), additional project ideas beyond the path - [Junior Developer Job Market 2026](https://scrimbaguide.tech/blog/junior-developer-job-market-2026/), why projects matter more than ever ## Start building now Stop watching. Start coding. Build these 10 projects and fill up your GitHub. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # React Updates in 2026: Does React 19.3 Change What You're Learning? Source: https://scrimbaguide.tech/blog/react-updates-for-learners/ React 19.3.0 shipped 2026-09-09 and npm has tagged it `latest` since. It is a minor release that adds features and removes nothing, so a React 19 course still teaches current React. Install whatever `npm create vite@latest` gives you, which resolves to 19.3.0, and keep `react` and `react-dom` on the exact same version. ## Current state as of 2026-09-28 | | Status | Source | | --- | --- | --- | | Latest stable | `react` 19.3.0 and `react-dom` 19.3.0, released 2026-09-09. Earlier backport patches for older lines (19.2.8, 19.1.9, 19.0.8) shipped on 2026-07-21. | [react.dev/blog: React 19.3](https://react.dev/blog/2026/09/09/react-19-3), [GitHub releases](https://github.com/facebook/react/releases) (marked Latest), npm `dist-tags.latest` = 19.3.0 | | What a beginner should install | Whatever a scaffold gives you. The `create-vite` 9.2.1 React template pins `react` and `react-dom` to `^19.2.8`, which resolves to 19.3.0 on install. react.dev's own app-creation guide leads with a framework: Next.js (`npx create-next-app@latest`), React Router v7 (`npx create-react-router@latest`) or Expo, and lists Vite, Parcel and Rsbuild for starting from scratch. Create React App does not appear on that page. | [create-vite@9.2.1 template package.json](https://cdn.jsdelivr.net/npm/create-vite@9.2.1/template-react/package.json), [react.dev/learn/creating-a-react-app](https://react.dev/learn/creating-a-react-app) | | Does a typical React 19 course still match | Yes. 19.3 is additive. Hooks, components, props, state, effects, forms and actions all work the same way a React 19 course recorded them. What a course taped before 2026-09-09 won't show you: the now-stable ``, `addTransitionType`, Fragment refs, `use(browser())` and Trusted Types support. | [react.dev/blog: React 19.3](https://react.dev/blog/2026/09/09/react-19-3) | Verdict: nothing here forces a course swap. Treat 19.3 as a chapter you add on top of what you already have, not a reason to start over. ## Does React 19.3 change what you're learning? No, not the fundamentals. Everything new in 19.3 sits on top of the React you already know, according to the official release post: - `` animates elements through the browser's View Transition API: entering, exiting, updating in place, or sharing a named element between two spots. It only animates updates you mark as Transitions, through `startTransition`, a Suspense reveal, or `useDeferredValue`. - `addTransitionType` lets you tag a state update so the same Transition can trigger a different animation, called from inside `startTransition`. - Fragment refs let you put a `ref` on a `` and get back a `FragmentInstance` with methods to manage focus, listen for events across its children, and connect an `IntersectionObserver` or `ResizeObserver` to the whole group. - `use(browser())` opts a component out of server rendering, so it only ever runs in the browser. - Trusted Types support lets React pass Trusted Types objects straight through instead of coercing them, which matters for apps running the Trusted Types browser API. - Server Components can now render Context imported straight from a `'use client'` module, no separate Provider wrapper needed. Verdict: all six belong after the basics. None of them replaces a lesson a beginner course teaches; they extend what you can do once hooks, state and effects are already comfortable. One behavior change you can actually run into: in Strict Mode, React now double-invokes Effects during hydration too, matching what it already did on the client, and it warns when you call `use` inside a conditional. ## What to do - Check what you have. Run `npm ls react react-dom` in any project and read the two version numbers. - Starting a new project? Run `npm create vite@latest my-app -- --template react` (or a framework command from react.dev, such as `npx create-next-app@latest`), then `npm install`. You'll land on 19.3.0 or later. - Upgrading an existing 19.x project? Run `npm install react@19.3.0 react-dom@19.3.0`. Always bump both together, to the same version. - Mid-course on a pinned version? If your course project pins React 18.3 or a React 19 release candidate, finish the course on that pinned version first. Don't upgrade in the middle of a lesson; a version change can shift behavior the instructor's recording doesn't show. - Leave canary and experimental builds alone. npm currently tags `canary` at `19.3.0-canary-d083ec1d-20260922` and there's a separate `experimental` tag. Both are pre-release builds for testing, not a newer stable release, and course code won't expect them. ### Fix: "Incompatible React versions: The react and react-dom packages must have the exact same version" The exact string, from the shipped `react-dom` 19.3.0 build: `Incompatible React versions: The "react" and "react-dom" packages must have the exact same version. Instead got:` followed by the two versions it found. Cause: your `react` and `react-dom` packages resolved to two different builds. This isn't limited to stable releases: a react.dev tracking issue opened 2025-11-19 hit this exact error when its ViewTransition sandbox examples loaded `react` at `19.3.0-canary-0972e239-20251118` against `react-dom` at `19.3.0-canary-fb2177c1-20251114`, the same base version but different canary build IDs. Fix: - Pin both packages to one exact version: `npm install react@19.3.0 react-dom@19.3.0`. - Check for duplicates: `npm ls react react-dom`. If it shows two copies, delete `node_modules` and your lockfile and reinstall. - In a browser sandbox like CodeSandbox or StackBlitz, set both dependency versions by hand to the same value; sandboxes don't always resolve semver ranges the way a local install does. This is a version mismatch, not a bug in your code. ## Refreshing your React after 19.3 If you want a refresher rather than a rebuild, [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) is Scrimba's free, hooks-first course: Bob Ziroll teaches 358 lessons across six modules that end in two capstones, Tenzies and Assembly: Endgame. I reviewed it with a Pro account in September 2026 and confirmed those numbers against the live course page the same day. If it clicks, [start Learn React free](https://scrimba.com/learn-react-c0e?via=u42d4986). ## Update log ### 2026-09-09: React 19.3.0 released React 19.3.0 shipped as the new `latest` on npm, per the [official release post](https://react.dev/blog/2026/09/09/react-19-3) and the [GitHub release](https://github.com/facebook/react/releases). It stabilizes `` and Fragment refs, adds `addTransitionType`, `use(browser())`, and Trusted Types support, and lets Server Components render Context from `'use client'` modules. The post lists no breaking changes. Learner verdict: safe to install, nothing to unlearn. ## Bottom line Keep learning with your React 19 course. Install whatever version a scaffold like Vite or Next.js gives you, which is 19.3.0 or newer as of 2026-09-28. Keep `react` and `react-dom` pinned to the same exact version, always. Add `` once the fundamentals, components, hooks, state and effects, are solid, not before. If React demand is still on your mind at a career level rather than a version level, [Is React still worth learning in 2026?](https://scrimbaguide.tech/blog/is-react-still-worth-learning-2026/) covers the jobs data. This page gets a new dated entry every time React ships a release worth knowing about. ## Ready to start learning? Get full access to all Scrimba courses, paths, and community with Scrimba Pro. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # Scrimba AI Engineer Path: Complete Guide (2026) Source: https://scrimbaguide.tech/blog/scrimba-ai-engineer-path-guide/ Scrimba's [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) runs 11.4 hours across nine modules and takes a working JavaScript developer to a deployed AI app: a hand-built ReAct agent, a RAG search over your own data, and a Node backend live on Render. It is Scrimba's smallest path, JavaScript-first, and built for developers adding AI skills, not for a Python-first machine learning track. Reviewed with a Pro account inside the path and its component courses, September 2026. ## What is an AI engineer? An AI engineer wires large language models into working software. You do not train models. You call APIs from OpenAI, Anthropic, or Mistral and build the prompt handling, retrieval, and tool-calling logic around them. The five skills the path teaches, in the order it teaches them: the messages array and streaming (prompt engineering), grounding answers in your own data (RAG), building systems that call tools and make decisions (agents), managing what stays in context as a conversation grows (context engineering), and MCP, the open protocol for connecting a model to external tools. ## What's inside the AI Engineer Path Nine modules, 162 scrims. Tom Chant opens the path with [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/), its largest module; Arsala Khan teaches Open-source Models and Context Engineering; Bob Ziroll and Guil Hernandez cover the rest. Per Borgen, who runs Scrimba, described the path's structure on the Scrimba Podcast rather than teaching most of it himself. The [path page](https://scrimba.com/ai-engineer-path-c02v?via=u42d4986) heads it "11.4 hrs," though the module list on our [full path review](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) adds to about 12.5. | Module | Length | What you build | | --- | --- | --- | | [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) (free sample) | 2.5 hrs | Gift Genie: a first API call through streaming, structured output, and a secured Node backend | | Deployment | 71 min | One Node app taken from localhost to Render, with staging and a health endpoint | | Open-source Models | 40 min | Hugging Face Inference, Transformers.js, running models locally with Ollama | | [Embeddings and RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) | 95 min | Chunking, embeddings in Supabase, similarity search, the PopChoice project | | [AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) | 117 min | A ReAct agent built by hand in nine parts, then an OpenAI functions agent | | [Context Engineering](https://scrimbaguide.tech/docs/courses/ai/context-engineering/) | 58 min | Managing and summarizing the context window | | [Vercel AI SDK](https://scrimbaguide.tech/docs/courses/ai/a-support-agent-with-vercel-ai-sdk/) | 113 min | A customer-support agent with retrieval, tool calling, and web search | | [Model Context Protocol](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/) | 43 min | An MCP server with tools, resources, and transports | | [DALL-E and GPT Vision](https://scrimbaguide.tech/docs/courses/ai/dall-e-and-gpt-vision/) | 62 min | Image generation and prompting GPT-4 with Vision | The order matters more than the topic list. You learn the API surface first, deploy something early, then build the data layer, then add tool-calling, then learn to manage context across all of it. That is the sequence a real project follows, and most intro AI courses skip straight to agents without the deploy step. If you want a smaller first build before committing to the path, our [beginner's guide to building your first AI agent in JavaScript](https://scrimbaguide.tech/blog/how-to-build-ai-agent-beginners-2026/) walks through a minimal ReAct loop on its own. ## Who should take this path? Take it if you already ship JavaScript or TypeScript and want the shortest route to agentic, retrieval-backed features in apps you build. Skip it if your goal is model research or a Python-first ML track (Python remains the dominant AI language, and this path does not pretend otherwise); skip it too if you do not yet know React, since the path assumes basic web app structure and no [Frontend](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) or [Fullstack](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) background. Prerequisites: JavaScript fundamentals (functions, async/await, calling an API with fetch) and a working knowledge of HTTP requests. No machine learning background is required or taught. For the full transition story, see how a [JavaScript developer can become an AI engineer without learning Python](https://scrimbaguide.tech/blog/how-to-become-ai-engineer-javascript-developer/). ## Is the AI engineer job market real in 2026? Yes, and it pays a premium. PwC's 2026 Global AI Jobs Barometer found a 62% wage premium for AI skills, up from 57% the year before. levels.fyi's AI Engineer title page puts mainstream-employer comp in the $134k-$193k range, with frontier labs pulling the top far higher (OpenAI's L2-L6 band runs roughly $251k to $1.28M). The New Stack's Tech Hiring in 2026 piece found AI skills now appear in 42% of software job descriptions, up from 8% in 2022. What employers want from an applied AI hire, the kind this path targets, is a small portfolio: a retrieval app over real documents, a tool-using agent that calls at least one external API, and a deployment that handles streaming responses. The path is sized to give you exactly those pieces. It is not sized to give you a research portfolio, and it will not by itself get you an interview at a frontier lab. ## Beyond the path: next steps Once you finish the path, these standalone courses deepen specific pieces of it: - [Build Serverless AI Agents with Langbase](https://scrimbaguide.tech/docs/courses/ai/serverless-ai-agents-with-langbase/), agents as deployable serverless pipes - [Intro to Mistral AI](https://scrimbaguide.tech/docs/courses/ai/mistral-ai/), the same RAG and function-calling ideas on a second model provider - [Prompt Engineering for Web Developers](https://scrimbaguide.tech/docs/courses/ai/prompt-engineering-for-web-developers/), the prompt side the path only touches in passing - [OpenAI Assistants API](https://scrimbaguide.tech/docs/courses/ai/openaiassistants/), build with OpenAI's APIs (note: OpenAI is transitioning developers from the Assistants API to the newer Responses API, so treat this as a stepping stone to the current tooling) The path's own Deployment module (updated in 2026) takes a Node app to Render with a staging environment and a health endpoint; the older Cloudflare and LangChain.js courses that used to sit next to it are no longer in the catalog. If you have not committed to Scrimba yet and want to see how this path stacks up against courses on other platforms, [the best AI engineering courses of 2026](https://scrimbaguide.tech/blog/best-ai-engineering-courses/) compares them side by side. ## Is the AI Engineer Path worth it? Yes, for the developer it targets: 11.4 hours is focused, not padded, and you write real AI code from the first scrim instead of watching slides. Pair it with the standalone AI courses above and you cover close to a dozen courses across the full stack, agents, RAG, MCP, and multimodal. Rating: 4.7/5. The half-point deduction is the Python gap: most production AI tooling ships Python SDKs first, and this path never touches Python. ## Related pages - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) | [All AI Courses](https://scrimbaguide.tech/docs/courses/ai/) - [Scrimba AI Courses](https://scrimbaguide.tech/docs/courses/ai/) - [Practice AI Engineering](https://scrimbaguide.tech/docs/practice/practice-ai-engineering/) - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) | [Scrimba Review 2026](https://scrimbaguide.tech/blog/scrimba-review/) **Q: Do I need a math or ML background?** No. AI engineering is about using language models through APIs, not building them. JavaScript knowledge is the main prerequisite. **Q: Is 11.4 hours enough to learn AI engineering?** It's enough to build real AI applications. Like all Scrimba content, actual learning time is 2-3x the content hours. For production mastery, also take the standalone AI courses after the path. **Q: Can I get an AI engineering job after this path?** The path gives you the foundational skills. To be competitive, combine it with portfolio projects (a RAG system, an AI agent, or an MCP server) and contribute to open-source AI projects. **Q: How competitive is the AI engineer job market?** AI roles are in high demand but competition is growing. Employers look for practical projects and API experience, not theory. Adding AI skills to existing web dev experience differentiates you from many junior candidates. ## Try the free Intro to AI Engineering lesson Build Gift Genie's first few scrims free, then Pro unlocks the rest of the AI Engineer Path. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # Scrimba Backend Developer Path Review (2026): Is It Worth It? Source: https://scrimbaguide.tech/blog/scrimba-backend-path-review/ Scrimba's [Backend Developer Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/) is 36.2 hours of Node, Express, SQL, TypeScript, and security, built for a JavaScript developer who already ships a frontend and wants the server half. It skips Python, Java, and Go entirely. Verdict: strong if you already know JS; skip it if you want a non-JS backend or have never written code. Reviewed the [Backend Developer Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/) with a Pro account, September 2026: all twelve modules expanded, plus the standalone [Learn Node.js](https://scrimbaguide.tech/docs/courses/javascript/nodejs/), [Learn Express.js](https://scrimbaguide.tech/docs/courses/javascript/expressjs/), and [Learn SQL](https://scrimbaguide.tech/docs/courses/backend/sql/) courses it draws from. ## What's inside the Scrimba backend path Twelve modules and 965 lessons add up to 36.2 hours; expand every nested group and it's 598 individual scrim rows, per the path's own [module breakdown](https://scrimbaguide.tech/docs/paths/backend-developer-path/). - Node (3.6 hrs). Tom Chant's REST API build, Wild Horizons (19 scrims), plus Routes & Paths (26 scrims). The standalone [Learn Node.js](https://scrimbaguide.tech/docs/courses/javascript/nodejs/) course covers the same ground in about 3.5 hours if you want it on its own, no framework, just Node's built-in `http` module. - Databases (3.7 hrs). SQL vs NoSQL, then Fundamentals of SQL (25 scrims), Creating and Joining Tables (11), and Advanced Logic and Conditions (nine). Gregor Thomson runs the same curriculum in the free [Learn SQL](https://scrimbaguide.tech/docs/courses/backend/sql/) course, all of it practiced on a vintage-car dealership's database. - Frameworks (6.7 hrs), the heaviest module. Express (Build an Express API, then a fullstack app with a 25-scrim authentication block and a 24-scrim Express-plus-TypeScript block) and a 21-scrim NestJS preview. The standalone [Learn Express.js](https://scrimbaguide.tech/docs/courses/javascript/expressjs/) course builds the same session-and-bcrypt vinyl store, Spiral Sounds, in about four hours. - Cybersecurity (5 hrs). STRIDE threat modeling, input safety, authentication patterns, and rate limiting, taught by Rachel Johnson and Jonathan Hill. - DevOps (5.6 hrs). Containers and Docker, deployment, GitHub Actions CI, continuous delivery, and CDNs, the module missing from the [Fullstack Developer Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/). - TypeScript, Git and GitHub, and Launching Your Career round it out, the last one built from data structures and algorithm practice rather than interview prep. Twelve modules, one language. Want the same skills in Python or Go? This isn't the path. ## Is the Scrimba backend path worth it? Yes, if you already write comfortable JavaScript and want routes, SQL, and deploys without redoing the whole frontend arc. The scrim format is why it works for backend material specifically: you edit Express route handlers and watch the response change, run SQL queries against a live database inline, and break a middleware chain to see the error handling fire. Tom Chant makes the case for going server-side in the Node course itself: "you're pretty unlikely to be building a full stack project with a vanilla node back end in the real world," which is exactly why the path spends only 3.6 hours on vanilla Node before moving you into Express and NestJS. Budget 8 to 10 weeks at 6 to 8 hours a week, 3 to 5 weeks at 12 to 15 hours a week, or 2 to 3 weeks full-time, per the [path's own time estimate](https://scrimbaguide.tech/docs/paths/backend-developer-path/). That's lesson time; real project builds push the calendar further. Start here: [the Backend Developer Path](https://scrimba.com/backend-path-c0tbi0l98f?via=u42d4986). ## Who is the Scrimba backend path for? The path is labeled Intermediate on purpose. It assumes JavaScript fundamentals (functions, async/await, arrays), basic HTTP and API knowledge, and comfort in a terminal. If any of that is new, start with the [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) first; it teaches the JavaScript this path builds on. It's the right call if you can already ship a UI and want APIs, a database, and a deploy pipeline without sitting through frontend material again. It's the wrong call if your job search targets a non-JS backend, or if you want one subscription that teaches everything from zero; that's the [Fullstack Developer Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) instead. ## Scrimba backend path vs other backend courses | Feature | [Scrimba Backend Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/) | The Odin Project | Udemy Node.js courses | | --- | --- | --- | --- | | Format | Interactive editor, code runs as you edit | Text lessons plus your own local setup | Passive video | | Cost | Scrimba Pro | Free | $10 to $15 on sale, $110+ list | | Structure | One 36.2-hour path, 12 modules | Self-paced JavaScript path, no published total hours | Individual courses, roughly 35 to 42+ hours each | | Projects | Built into the lessons: Wild Horizons, Spiral Sounds, DevMatch | Self-directed | Follow-along | | Community | Discord | Discord | Course Q&A only | The Odin Project's [Full Stack JavaScript path](https://www.theodinproject.com/paths/full-stack-javascript) is free and includes an Express-based NodeJS course, but it publishes no total-hours estimate for the curriculum. Udemy's catalog runs 35 to 42+ hours per course at list prices over $110, though sales regularly drop them to $10 to $15. Scrimba's edge is the format, not the price: you never just watch, you edit and run the code inline. If cost is the deciding factor and you have the discipline to work through text lessons alone, The Odin Project covers similar ground for free. If you want a broader, language-agnostic backend curriculum, [Scrimba vs Boot.dev](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-boot-dev/) is the comparison to read next. Live Scrimba Pro pricing, including the current discount, is at [scrimba.com/our-pricing](https://scrimba.com/our-pricing?via=u42d4986). ## Strengths and limits Where it delivers: 36.2 hours with no filler, an interactive format that has you writing backend code from lesson one, and a stack (Node, Express, SQL) that lines up with the roughly $120k average U.S. back end developer salary ZipRecruiter reports. It also folds naturally into Scrimba's frontend and fullstack paths if you started there. Where it stops: no Python or Go, so a non-JS backend job search needs another platform. DevOps coverage is real (Docker, GitHub Actions CI, continuous delivery) but not deep enough to replace a dedicated DevOps course. And at 36.2 hours it covers a fraction of what a from-scratch curriculum like The Odin Project's does, by design: it assumes you already have the frontend fundamentals that path teaches from scratch. ## Related pages - [Backend Developer Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/) | [Fullstack Developer Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) - [Scrimba Learning Paths](https://scrimbaguide.tech/docs/paths/) | [Intro to NestJS](https://scrimbaguide.tech/docs/courses/javascript/nestjs/) - [Backend & Database Courses](https://scrimbaguide.tech/docs/courses/backend/) | [All Paths](https://scrimbaguide.tech/docs/paths/) - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) | [Scrimba Review 2026](https://scrimbaguide.tech/blog/scrimba-review/) **Q: Does the Backend Path teach Docker and deployment?** Yes. The DevOps module covers containers and Docker, deployment, GitHub Actions CI, and continuous delivery in about 5.6 hours. What it doesn't cover in depth is automated testing or the LinkedIn and interview-prep block that the Frontend and Fullstack paths include. **Q: Should I do the Frontend or Backend Path first?** Frontend first, unless you already know JavaScript. The Backend Path is labeled Intermediate and assumes the fundamentals the Frontend Path teaches from zero. **Q: Does the Backend Path cover TypeScript?** Yes. TypeScript is its own module, and the Frameworks section includes a dedicated 24-scrim Express-plus-TypeScript block. Take the standalone Learn TypeScript course first if you want the fundamentals on their own. **Q: How long does the Backend Path take?** 36.2 hours of lessons across 12 modules. Most learners finish in 3 to 5 weeks at 12 to 15 hours a week, or 8 to 10 weeks at 6 to 8 hours. ## Try Scrimba free before you commit to the Backend Path See the editor and the Node module for yourself, then upgrade to Pro when you're ready for the full path. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # Scrimba Discount Codes 2026: No Public Codes Work Source: https://scrimbaguide.tech/blog/scrimba-discount-codes-2026/ No public Scrimba coupon code works in 2026, and none ever has. Scrimba prices by eligibility, not promo code: annual billing, our 20%-off affiliate link, a verified academic email, the GitHub Student Developer Pack, and automatic regional pricing. Stack whichever ones you qualify for and skip the SAVE50 sites. Checked against Scrimba's official pricing page and help center, September 2026. You're comparing Scrimba Pro's price against a coupon site that promised SAVE50 or WELCOME20. Those codes don't exist and never have; here's what actually cuts the price. ## Why don't Scrimba coupon codes work? Coupon aggregator sites publish "Scrimba coupon code" pages regardless of whether a real code exists, because the search volume is there either way. What they list is expired affiliate links the affiliate has since rotated, screenshots staged to inflate a "verified today" count, or codes that were never real. Scrimba discounts by eligibility (student, region, GitHub Student Pack) and by commitment (annual billing). No promo-code field sits at checkout, so no SAVE25 or BLACKFRIDAY26 string will ever do anything there. ## Is annual billing cheaper than monthly? Yes, and it's the discount everyone qualifies for. On the [official pricing page](https://scrimba.com/our-pricing?via=u42d4986), toggle to annual and the per-month rate drops. Scrimba doesn't publish a fixed percentage and the exact savings shift by region, but annual beats monthly the moment you commit to more than about three months of study. Take it. ## How do I get 20% off Scrimba Pro? Go through a partner link. We're a Scrimba affiliate, and [our link to Scrimba's pricing page](https://scrimba.com/our-pricing?via=u42d4986) applies a 20% discount on Pro at checkout. We earn a small commission, you pay less, and the discount is active as of September 2026. It's the same partner-link mechanic most independent SaaS reviewers run, nothing exclusive to us. If you're signing up anyway, this is the simplest lever to pull. Before you spend anything: the cheapest discount is still the free tier. Scrimba gives away 24 full courses, no card, no trial, including three that carry you from zero to shipping projects. [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) runs Per Borgen through 238 lessons in about 9.4 hours and has you build a passenger counter, a blackjack game, a Chrome extension and a mobile app. [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) is Bob Ziroll teaching 358 lessons across 15.1 hours, ending in two capstones: a Tenzies dice game and an Assembly: Endgame word game. [Learn TypeScript](https://scrimbaguide.tech/docs/courses/typescript/learn-typescript/) is a faster 4.2-hour, 79-lesson add-on, also with Ziroll, that layers types onto a React game you already built and a new typed Express API. Sample the format first via the [public demo scrim](https://scrimba.com/s0v687325e?via=u42d4986); a one-time "20% off Pro" banner pops up on landing, and closing it leaves the lesson open, free, no signup. Then decide whether the affiliate discount is worth pulling. The full [pricing breakdown](https://scrimbaguide.tech/docs/pricing/) covers regional pricing too. ## Is there a Scrimba student discount? Yes, and it's bigger than the affiliate link, but Scrimba doesn't put it at checkout. Email [help@scrimba.com](mailto:help@scrimba.com) from your `.edu`, `.ac.uk`, or equivalent academic address with the subject "Student discount request," and support verifies and applies it manually, usually within a few business days. Our [student discount page](https://scrimbaguide.tech/docs/pricing/student-discount/) has the full request script and how it compares against the GitHub Student Pack and regional pricing side by side. Terms vary and Scrimba can change them without notice, so confirm the current number by email rather than trusting a percentage from an old blog post. ## Does the GitHub Student Pack include Scrimba? Yes. If you're already verified through [GitHub Education](https://education.github.com/pack), Scrimba is a Pack partner and the redemption gives one free month of Pro. - Open the [GitHub Student Developer Pack offers page](https://education.github.com/pack). - Search for Scrimba and follow the redemption link. - After the free month, billing rolls over to the standard rate. Cancel before renewal if you don't want to continue. This stacks with annual billing if you switch to annual once the free month ends, but confirm current stacking rules with Scrimba support before counting on it. ## Does Scrimba have regional or PPP pricing? Yes, and it applies automatically, no code needed. Visit the pricing page from your real connection and Scrimba adjusts the displayed Pro price down for countries with lower average purchasing power, including India, Brazil, Nigeria and Indonesia. Don't use a VPN to fake your location. Scrimba's billing system checks the location tied to your payment method, and a mismatch triggers an account ban. Public Trustpilot reviews and Scrimba's own support posts back this up; it's a hard rule, not a rumor. ## What discount methods don't work? - Public coupon codes like SAVE50, SCRIMBA25, etc. They don't exist. - Code generators. There is no algorithm; codes aren't random strings tied to a server-side validator. - Reusing someone else's affiliate or student link if it's tied to a specific account. - Account sharing. Against the terms of service and breaks your progress tracking anyway. - Multiple new-account discounts. One per person. ## What's the cheapest way to pay for Scrimba Pro in 2026? Stack what stacks. Regional pricing applies automatically with no action from you. On top of that, go through the affiliate link for 20% off, or get the student discount by email if you qualify (one discount per checkout, not both). Then choose annual billing. That combination is the floor on what you can legitimately pay. Students should claim the GitHub Student Pack free month first, decide whether to keep going, then switch to annual through the student channel once verified. ## What's Scrimba's refund policy? Scrimba backs your first purchase with a 7-day money-back guarantee, one refund per account, as its [pricing page](https://scrimba.com/our-pricing?via=u42d4986) states. If the format doesn't click within your first week, request a refund via [help@scrimba.com](mailto:help@scrimba.com). Our [refund policy breakdown](https://scrimbaguide.tech/docs/pricing/refund-policy/) covers the full process, including what happens to your progress after you cancel. ## Sources - [Scrimba's official pricing page](https://scrimba.com/our-pricing?via=u42d4986) - the live source of truth. - [Scrimba help center](https://scrimba.helpscoutdocs.com/) - refund window, student discount policy, account terms. - [GitHub Student Developer Pack](https://education.github.com/pack) - Scrimba as a partner offer. - [Scrimba on Trustpilot](https://www.trustpilot.com/review/www.scrimba.com) - real reviews, including VPN-ban warnings and renewal complaints. ## Frequently asked questions **Q: Is there a free trial?** Not a credit-card trial. Scrimba's 24 free courses, including the 15.1-hour Learn React, work as the trial instead. Source: [Scrimba Help Centre](https://scrimba.helpscoutdocs.com/article/73-whats-the-difference-between-pro-and-free) **Q: What's the refund policy?** Full refund within 7 days of your initial purchase, one refund per account. Request via help@scrimba.com. Source: [Scrimba Help Centre](https://scrimba.com/our-pricing) **Q: Does the student discount apply at renewal?** Verify with Scrimba support directly. Terms vary and you may need to re-verify enrollment each term. Source: [Scrimba Help Centre](https://scrimba.helpscoutdocs.com/article/19-do-you-offer-student-discounts) **Q: Can I stack the affiliate discount with the student discount?** No, checkout applies one discount at a time. Email help@scrimba.com if you qualify for both and want the larger one applied. **Q: Will a Black Friday or Cyber Monday sale ever happen?** Scrimba runs occasional limited promotions, but they aren't reliable enough to wait for. Annual billing and the levers above are the consistent ways to save. ## Try Scrimba before you pay anything Start with 24 free courses, no card. When you're ready for Pro, our link still applies the 20% discount. [Start free on Scrimba](https://scrimba.com/?via=u42d4986) --- # Scrimba Explain From Claude Code: MCP Setup, PR Explainers and the CI Endpoint Source: https://scrimbaguide.tech/blog/scrimba-explain-claude-code-pr-explainers/ Scrimba Explain exposes two MCP endpoints: one for your own agent session, one for pull requests. Claude Code connects to either with one command or one JSON file, reads your repository or diff, and streams a narrated video lesson into Scrimba. Drafts cost nothing until someone opens and claims the link. I ran both endpoints against a public Anthropic repo and a merged pull request, and this post is what came back, including the parts that went wrong. If you have not met the tool yet, the [Scrimba Explain review](https://scrimbaguide.tech/blog/scrimba-explain-review/) covers what an explainer is and whether the output is any good. The [Scrimba Explain reference page](https://scrimbaguide.tech/docs/how-it-works/scrimba-explain/) has the quotas and visibility rules in tables. What follows is the developer side only: the agent endpoints, the setup, and two real runs. ## Two endpoints, one difference MCP is the Model Context Protocol, the open standard coding agents use to call outside tools. Scrimba runs two remote MCP servers for Explain, and they differ in who can watch the result by default. | | `https://scrimba.com/explain/mcp` | `https://scrimba.com/explain/pr/mcp` | | --- | --- | --- | | Meant for | Your own agent session: a branch, a subsystem, a bug you just fixed | CI jobs and pull requests | | Tools | `start_explainer_stream`, `append_explainer_chunk`, `finish_explainer_stream`, `create_playlist` | The three stream tools only, no playlists | | Default visibility | Private draft until claimed (you can ask for unlisted) | Unlisted, so a reviewer can watch without an account | | Authentication | None. No token, no login step before creation | None | Both are streamable HTTP servers, so they also work in Cursor, Windsurf, Zed and any agent that speaks MCP ([docs.scrimba.com/explain/mcp](https://docs.scrimba.com/explain/mcp?via=u42d4986)). Playlists on the standard endpoint hold 2 to 12 lessons behind one claim link. ## Adding it to Claude Code Scrimba's docs give one command ([docs.scrimba.com/explain/claude-code](https://docs.scrimba.com/explain/claude-code?via=u42d4986)): ``` claude mcp add --transport http scrimba-explain https://scrimba.com/explain/mcp ``` That writes the server into your Claude Code config for good. I did not want that on a shared machine, so I used the per-run form instead. It takes a JSON file and a flag, and nothing persists: ``` { "mcpServers": { "scrimba": { "type": "http", "url": "https://scrimba.com/explain/mcp" } }} ``` ``` claude -p "your prompt here" \ --mcp-config scrimba.mcp.json --strict-mcp-config \ --allowedTools "mcp__scrimba__*,Read,Glob,Grep" < /dev/null ``` `--strict-mcp-config` tells Claude Code to ignore every other MCP server on the machine for this run. The `< /dev/null` matters too: without it, headless Claude waits three seconds for piped input and prints a warning. The PR variant is the same file with `pr/mcp` in the URL. Note the shape of the `--allowedTools` glob. My first attempt used `mcp__scrimba*` and Claude Code ignored the rule with a warning: a wildcard is only allowed after the full `mcp____` prefix. Scrimba's docs sidestep this by listing the three tool names in full, which also works. ## What the tool list looks like Asked to list its tools without calling them, Claude Code reported four on the standard endpoint. `start_explainer_stream` takes a title (under about 45 characters), an optional description, a frame mode (square, portrait or landscape) and a visibility of private or unlisted. It returns the draft URL, a stream token and the authoring contract. That contract is the interesting part. It is about 67 KB of rules for the OPML slide format: code, diff, diagram (Mermaid), math, animation, image and infographic items, plus `` blocks that link narration to slide anchors. Your agent writes the whole lesson in that format. Scrimba only supplies the voice and the pictures. `append_explainer_chunk` pushes OPML and returns what is left of a 512,000 byte budget and ten minutes of narration. `finish_explainer_stream` closes the draft. `create_playlist` opens one claim link and a token per lesson. ![Scrimba Explain, MCP flow diagram: an agent writes the lesson, Scrimba only renders it after you claim the link.](https://scrimbaguide.tech/img/blog/scrimba-explain-claude-code-pr-explainers/mcp-stream-flow.webp) *The agent does the reading and writing. Scrimba's servers only render after you open and claim the link.* Diagram by scrimbaguide.tech. ## The explainer Claude Code made from a real repo I cloned Anthropic's public `anthropic-quickstarts` repository and ran this from the `agents/` folder, one attempt, no edits: Read agent.py (the `Agent._agent_loop` method) and utils/tool_util.py. Then, using the Scrimba MCP tools, create ONE explainer that explains how this agent decides to call a tool and feeds the result back into the model, for a JavaScript developer who has called an LLM API once, with a diagram slide and a quiz. Make it unlisted. When done, reply with the explainer URL and a short summary of the slides you wrote. Claude Code read both files, opened the stream with the title "Agent tool loop: how Claude calls tools" and visibility unlisted, then sent two chunks of OPML (6.6 KB and 7.3 KB). The run took 160 seconds and 13 turns. Claude Code reported about USD 1.20 of API usage for it, which is the real cost of an agent-authored explainer, since the draft itself is free. The result is at [scrimba.com/explain/guide049ig84ai](https://scrimba.com/explain/guide049ig84ai) and embedded below, so you can step through it while reading. It plays for 5 minutes 12 seconds across 14 narrated slides. The transcript headings, as rendered on the page: Agent tool loop, One call vs. a loop, One turn of the agent loop, What every API call carries, Ask the model then look for tool_use, Record the model's turn first, Run tools or return, Executing one tool call, Several tool calls in one reply, The conversation grows each pass, The loop in six steps, Quiz 1, Quiz 2, Answers. ![Scrimba Explain, fullscreen player on a diagram slide: a sequence chart of an agent calling a tool and getting a result back.](https://scrimbaguide.tech/img/blog/scrimba-explain-claude-code-pr-explainers/agent-loop-diagram-slide.webp) *The diagram slide at 0:40, written by Claude Code as Mermaid and rendered by Scrimba. The Publish to community button marks this as the owner's view.* Screenshot of scrimba.com, taken by scrimbaguide.tech. The agent-loop explainer, 5:12, 14 slides, written by Claude Code over the MCP endpoint and rendered by Scrimba.[Open on scrimba.com](https://scrimba.com/explain/guide049ig84ai) I checked the content against the source. Both quiz answers are right: with no `tool_use` block the loop returns, and a tool that throws becomes a `tool_result` with `is_error` set. The narration's claim that the assistant turn is appended before any tool runs matches the code. One wrinkle: the code is Python and the audience was a JavaScript developer, and Claude flagged that in the narration rather than translating it, with `asyncio.gather` explained as `Promise.all`. The quiz is two card slides plus an answers slide. The MCP contract has no interactive quiz item, so there is no answer checking, unlike some web explainers. ## Drafts are free until you claim them The quota applies when a signed-in Scrimba user opens the link and claims the draft ([docs.scrimba.com/explain/limits-and-plans](https://docs.scrimba.com/explain/limits-and-plans?via=u42d4986)). Your agent can make twenty drafts and you pay for none of them until one is claimed. Images generate on first open and narration on claim plus first view, so an unclaimed draft is only text sitting on Scrimba's servers. For me the link opened on a "Claim this explainer to watch it" screen, and within about ten seconds it moved on to the playing explainer without a click. Being signed in is enough. A free account gets 10 claims for life and Pro gets 100 a month, so the agent route is where the Pro quota starts to matter. Details are on [Scrimba's pricing page](https://scrimba.com/our-pricing?via=u42d4986). ## Explaining a real pull request For the second run I used the PR endpoint on a merged pull request from the same repo: anthropics/anthropic-quickstarts #485, "Slack quickstart: sign the reply route so forged session metadata is ignored", 4 files, +124/-6. I saved the description and the diff with `gh` and gave both as files: Make a Scrimba explainer of this pull request. The PR description is in pr-485.md and the full diff is in pr-485.diff (read both with the Read tool). Audience: a JavaScript developer who has shipped one webhook. Use a diff slide for the key change. When done, reply with the explainer URL. This run took 135 seconds and 14 turns, one 18 KB chunk, 12 narrations, about 7 minutes of audio. Claude Code chose landscape mode and the title "Signing webhook routes with HMAC (PR 485)". It is at [scrimba.com/explain/guide04mover9n](https://scrimba.com/explain/guide04mover9n). The slide order tells you how the agent read the change: a sequence diagram of the Slack bridge, cards on why the old agent-ID check was forgeable, an animation of the forged route, the diff slide on the `verifyRoute` guard, three code slides (key derivation, kickoff ordering, constant-time compare), a lifecycle diagram, and a closing slide on consequences like secret rotation. Claude added one caveat in its reply: the "after" pane of the diff omits a long `console.warn` line so both panes fit the frame. That is the format doing what a PR description cannot. A description says what changed. The explainer spends its first two minutes on why the old check failed, which is the part a reviewer who did not write the code needs. ## The GitHub Action, per Scrimba's docs I did not run this part, so treat it as Scrimba's description rather than my test. The docs say `npx pr-explainer` generates a `.github/workflows/scrimba-pr-explainer.yml` file that produces an explainer for each pull request and skips draft and fork PRs unless you explicitly allow them ([docs.scrimba.com/explain/agent-plugins-and-ci](https://docs.scrimba.com/explain/agent-plugins-and-ci?via=u42d4986)). The headless recipe on the same page is the `claude -p` form shown above, with the three PR tools listed in `--allowedTools`. Going by my two runs, a team wiring this into every PR should expect roughly a dollar of Claude usage per explainer. Scrimba's side stays free until someone claims it. ## Limits, rate limits, and what actually broke The documented limits: 10 minutes of narration per explainer, idle streams are auto-completed after 30 minutes, and rate limits are shared across every Scrimba MCP endpoint, answered with a `429` and a `Retry-After` header. The contract adds upload limits of 8 MB per file and 12 pictures. I hit none of these across two creations, and no auth or quota error appeared. What did break was on the Claude Code side. On every `start_explainer_stream` call the 67 KB contract exceeded Claude Code's tool result window, so it was saved to a file and Claude spent six or seven extra tool calls reading it back with `jq` and `sed`. That is about half the wall time of each run. In auto permission mode those shell calls ran without asking; on a default install they would prompt, so allow `Bash` too or expect to approve a few reads. ## Privacy defaults for code explainers Standard endpoint drafts are private until claimed, and stay private unless you asked for unlisted, as I did. PR endpoint drafts are unlisted from the start ([docs.scrimba.com/explain/privacy-and-sharing](https://docs.scrimba.com/explain/privacy-and-sharing?via=u42d4986)). Unlisted means anyone with the link can watch, so an unlisted explainer of a private repo is only as private as the link. Two things I could not find stated anywhere: how long an unclaimed draft is kept, and what Scrimba does with the code your agent streams into it. If your repository is confidential, that is the question to ask before the first run. ## When a video beats a PR description A PR description is enough when the diff is small and the reviewer already knows the subsystem. The explainer earned its seven minutes on PR 485 because the change only makes sense once you understand how the Slack bridge trusts session metadata, and the diff does not say that. The same applies to onboarding: the agent loop explainer above is a file a new hire would otherwise read cold. Scrimba's [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) has Bob Ziroll walk you through building that same decide-call-observe loop by hand, 31 scrims before OpenAI function calling replaces the regex you just wrote. [Intro to Model Context Protocol](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/) has Maham Codes build the kind of tool-and-resource server these two endpoints extend, one weather tool, one resource, in 17 scrims. After this post you can add the server, make one draft of a branch you understand, check it against the code, and decide whether a claim is worth one of your ten. ## Claim your first explainer on a free account A free Scrimba account is enough to claim your first explainers and test the format on your own code before the quota matters. [Try Scrimba free](https://scrimba.com/?via=u42d4986) ## References - [Scrimba Docs, Claude Code](https://docs.scrimba.com/explain/claude-code?via=u42d4986): the `claude mcp add` command, the four tools, and the "images on first open, narration on claim" rule. - [Scrimba Docs, MCP](https://docs.scrimba.com/explain/mcp?via=u42d4986): the endpoint, streamable HTTP, playlists of 2 to 12 lessons, asking for unlisted. - [Scrimba Docs, Agent plugins and CI](https://docs.scrimba.com/explain/agent-plugins-and-ci?via=u42d4986): the `/explain/pr/mcp` endpoint, the headless recipe, `npx pr-explainer`, and the narration, idle and 429 limits. - [Scrimba Docs, Limits and plans](https://docs.scrimba.com/explain/limits-and-plans?via=u42d4986): 10 explainers for life on Free, 100 a month on Pro, drafts free until claimed. - [Scrimba Docs, Privacy and sharing](https://docs.scrimba.com/explain/privacy-and-sharing?via=u42d4986): private default over MCP, unlisted for the PR endpoint. - [anthropics/anthropic-quickstarts](https://github.com/anthropics/anthropic-quickstarts): the `agents/agent.py` and `utils/tool_util.py` files, and pull request #485, used for the two runs. - Two runs on 2026-09-20 with Claude Code CLI 2.1.278: explainers [guide049ig84ai](https://scrimba.com/explain/guide049ig84ai) and [guide04mover9n](https://scrimba.com/explain/guide04mover9n). **Q: Do I need a Scrimba account or token to connect Claude Code to Explain?** Not to create a draft. Both endpoints accepted the stream with no token, header or login step. You need a signed-in Scrimba account to open the link and claim the explainer, which is when it starts to play and when it counts against your quota. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/claude-code?via=u42d4986) **Q: What is the difference between /explain/mcp and /explain/pr/mcp?** The PR endpoint has the three stream tools and no playlists, and its drafts are unlisted by default so a reviewer can watch without an account. The standard endpoint adds create_playlist and keeps drafts private until claimed unless you ask for unlisted. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/agent-plugins-and-ci?via=u42d4986) **Q: Does an explainer made by Claude Code count against my free quota?** Only when you claim it. Drafts are free however many the agent makes. Claiming one takes one of the 10 lifetime explainers on a free account or one of the 100 a month on Pro. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/limits-and-plans?via=u42d4986) **Q: How long does it take Claude Code to make an explainer?** My two runs took 160 and 135 seconds, 13 and 14 turns each. About half of that was Claude Code reading the roughly 67 KB authoring contract back from a file because it exceeded the tool result window. Claude Code reported about USD 1.1 to 1.2 of API usage per run. **Q: Why did Claude Code ignore my --allowedTools rule for the Scrimba server?** A wildcard is only allowed after the full server prefix. Use mcp__scrimba__* rather than mcp__scrimba*, or list the three tool names in full as Scrimba's docs do. **Q: Can I run this in CI on every pull request?** Scrimba's docs say npx pr-explainer generates a GitHub Actions workflow that makes an explainer per PR and skips draft and fork PRs unless you explicitly allow them. I have not run the Action myself; the headless claude -p form it wraps is the one I tested. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/agent-plugins-and-ci?via=u42d4986) **Q: Is the code I stream into Scrimba Explain private?** Drafts from the standard endpoint are private until claimed; PR endpoint drafts are unlisted, so anyone with the link can watch. Scrimba's docs do not state how long unclaimed drafts are kept or how the streamed code is handled, so ask before pointing it at a confidential repository. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/privacy-and-sharing?via=u42d4986) **Q: What are the limits per explainer?** Ten minutes of narration, a 512,000 byte OPML budget, uploads of 8 MB per file and 12 pictures, idle streams that are auto-completed after 30 minutes, and shared rate limits that return a 429 with a Retry-After header. I did not hit any of them in two runs. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/agent-plugins-and-ci?via=u42d4986) --- # The Explain Button Inside Scrimba Lessons: How It Works and When to Press It Source: https://scrimbaguide.tech/blog/scrimba-explain-inside-courses/ Every Scrimba lesson has an EXPLAIN button in its header. Pause, type a question, and Scrimba builds a short narrated video from that lesson: its files, your highlighted code, and the teacher's narration to that point. It costs one explainer from your allowance, 10 for life on Free or 100 a month on Pro, and stays attached to the lesson. Tested with a Pro account on the "Chunking text from documents" lesson in [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/), Guil Hernandez's 94-minute course on retrieval-augmented generation, September 2026. I pressed the button once, with a deliberately picky prompt, to see what it sends and what it builds. Here is what got sent, what came back, and the three moments in a course where it earns its cost. The [Scrimba Explain reference page](https://scrimbaguide.tech/docs/how-it-works/scrimba-explain/) covers all five entry points and the quota table, and the [tested review](https://scrimbaguide.tech/blog/scrimba-explain-review/) covers the web, Chrome and Claude Code routes. This post only covers the button inside a scrim. ## Where the button is A scrim is Scrimba's lesson format: a recorded screencast you can pause at any moment and edit the code the teacher is working on (see [how scrims work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/)). The EXPLAIN button sits at the top right of the scrim header, next to the volume and layout controls. Hover it and the tooltip reads "Explain this to me". Clicking it pauses the scrim and opens a small dialog with the same title. It has one text input, placeholder "What would you like explained more?", and a single blue button, CREATE EXPLAINER. ![Scrimba Learn RAG, Chunking text from documents lesson: a full-screen slide with the Explain button visible top right.](https://scrimbaguide.tech/img/blog/scrimba-explain-inside-courses/rag-chunking-lesson-explain-button.webp) *The button is easy to miss. It sits in the header at the top right, past the lesson timer.* Screenshot of scrimba.com, taken by scrimbaguide.tech. You need to be signed in, and the button is hidden on scrims locked for your plan, according to Scrimba's [Explain in scrims page](https://docs.scrimba.com/explain/scrims?via=u42d4986). [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) is a Pro course, so on a free account you would test this on a free lesson instead. ## What gets sent The dialog's description says Scrimba "creates an explainer video using this scrim as context, with emphasis on any code you've highlighted". The docs spell out what "this scrim as context" means. Five things go in: - the scrim's title and the course it belongs to - every file open in the editor - any code you highlighted - the teacher's narration up to the point where you paused - the paused moment itself ![Diagram showing how Scrimba Explain turns lesson context and your question into an explainer video.](https://scrimbaguide.tech/img/blog/scrimba-explain-inside-courses/what-explain-sends.webp) *The four boxes in the group are collected automatically. The question below them is the only thing you type.* Diagram by scrimbaguide.tech, based on docs.scrimba.com/explain/scrims and one test. Two of those five change how you should use it. Narration stops at your pause point, so pausing at minute two gives Explain two minutes of lecture. And the highlighted code becomes the anchor of the explainer, which is why the first step is to select the lines, not to type. ## The worked example: the Learn RAG chunking lesson [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) runs one flat list of 22 scrims that end in a solo project called PopChoice, which embeds three quiz answers and searches a Supabase vector store for the closest-matching movie. The "Chunking text from documents" lesson sits well into the course, at 9:36 long, the longest scrim in the course. It splits a `podcasts.txt` file with LangChain's `RecursiveCharacterTextSplitter`, using `chunkSize: 150` and `chunkOverlap: 15`, and gets 78 chunks. I paused at 9:29, so the whole narration was in context, and highlighted the four lines that build the splitter. Then I typed a long prompt on purpose. I wanted to see whether the button treats the question as a hint or as a spec: Explain why this lesson splits podcasts.txt into chunks before it creates embeddings. Anchor on the highlighted code: `new RecursiveCharacterTextSplitter({ chunkSize: 150, chunkOverlap: 15 })`. Audience: a JavaScript developer who has called an LLM API once and just watched this scrim. Cover three things. 1) What goes wrong when chunks are too large: one vector averages several topics, you can hit the embedding model's token limit, and the retrieved chunk bloats the chat completion prompt. 2) What goes wrong when chunks are too small: sentences lose their surrounding context, fragments make no sense on their own, and you store and search more vectors for weaker matches. 3) How chunk size relates to the similarity search that comes next: the user's short question is embedded and compared with every chunk vector, so chunks should be about as specific as the questions people will ask; explain why chunkOverlap: 15 helps at the boundaries. Use JavaScript code, not Python. Include one short diagram slide: document -> chunks -> embeddings -> vector store -> query match. Finish with a quiz. ![Scrimba Explain dialog over a Learn RAG lesson: a text input with a typed prompt and a Create Explainer button.](https://scrimbaguide.tech/img/blog/scrimba-explain-inside-courses/explain-modal-prompt-typed.webp) *The input is one line, so a long prompt scrolls. It still accepted all of it.* Screenshot of scrimba.com, taken by scrimbaguide.tech. The explainer was playing about five seconds later. It did not open a new tab. It appeared as an overlay player on top of the scrim, and the URL gained an `;explain/` segment. The lesson sidebar picked up a new Explainers section with one entry, "Why Chunking Matters for RAG at 9:30", the timestamp being where I pressed the button. ![Scrimba Explain overlay on a Learn RAG lesson: a video title card playing over the paused course screen.](https://scrimbaguide.tech/img/blog/scrimba-explain-inside-courses/explainer-overlay-in-lesson.webp) *The overlay covers the scrim rather than replacing it. Close it and you are back at 9:29.* Screenshot of scrimba.com, taken by scrimbaguide.tech. The result is embedded below, so you can watch it here before reading the breakdown. The explainer the EXPLAIN button produced from the highlighted splitter code, 1:31, seven slides.[Open on scrimba.com](https://scrimba.com/explain/guide0ab07v8g9) It has seven transcript sections: - Why Chunking Matters - The splitting logic, a code slide showing `index.js` - The RAG pipeline, a diagram from Document to Chunks to Embeddings to Vector Store to Similarity Match - Risks of large chunks - Risks of small chunks - The power of overlap - Testing your knowledge The quiz asks why chunk size should be similar to the expected user questions. Of the three options, the intended answer is obviously the similarity one. The explainer stayed in JavaScript and reused the exact splitter config from the lesson. ![Standalone Scrimba Explain page for a Learn RAG lesson: a video player, a full transcript, and a Back to lesson link.](https://scrimbaguide.tech/img/blog/scrimba-explain-inside-courses/explainer-page-transcript-back-to-lesson.webp) *The standalone page adds a Back to lesson chip and the full transcript. The transcript is what makes it worth keeping.* Screenshot of scrimba.com, taken by scrimbaguide.tech. On accuracy: diluted vectors, token limits, prompt noise, lost context and overlap as a bridge all match what the teacher says. One line, that thousands of tiny vectors make the search space "too noisy", is a simplification I would not repeat in an interview. The disclaimer under every explainer, "Explain is AI and can make mistakes", is there for a reason. ## Three moments to press it One explainer answered one question, so this is not a study. It does show what the button is good at, and each moment below maps onto something it did in the test. ### You are confused by a line The teacher wrote `chunkOverlap: 15` and moved on. Highlight that line, ask "why does this exist and what breaks at zero", and the explainer's anchor is that line, with the lesson's own variable names. In my test it opened on the highlighted block and gave overlap its own animated section. A generic "chunking explained" search would give you a Python tutorial with different names. ### You want the why behind a config value The lesson tells you 150 characters works for this file. It does not spend long on what goes wrong at 1,500 or at 15. My prompt asked for both failure modes and got a card slide for each. A screencast cannot answer this kind of question because it was recorded in advance. ### You want to check a rule of thumb The teacher's rule is to optimize for the smallest chunk that still makes sense without surrounding context. I asked how that relates to the similarity search. The explainer's answer: chunks should be about as specific as the questions people will ask. That is a better version of the rule than the one I had in my head. If you are heading toward the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/), this is the sort of thing that comes up again in [context engineering](https://scrimbaguide.tech/docs/courses/ai/context-engineering/) and [AI agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/). All three worked because I had already tried to answer the question myself before pressing the button. It cannot tell you what you do not know. It answers the question you bring. ## What it costs you Each press spends one explainer from the same allowance as the web tool. A free Scrimba account gets 10 explainers for the life of the account, and they do not renew. Pro gets 100 a month ([limits and plans](https://docs.scrimba.com/explain/limits-and-plans?via=u42d4986); plan prices are on [Scrimba's pricing page](https://scrimba.com/our-pricing?via=u42d4986)). Ten lifetime explainers across a 20-lesson course is not enough to press the button whenever you slow down. It is enough for the three moments above, maybe twice each. Follow-up questions and the Go deeper button each spend another one, so a curious evening on one lesson can cost four. Watching an explainer you already made is free. ## Explain versus asking the Discord Scrimba's Discord is free on the basic plan, and Pro adds the Pro-only channels where instructors and code reviewers hang out ([Pro vs Free](https://scrimbaguide.tech/docs/pricing/pro-vs-free/)). So for a stuck learner the comparison is a free explainer against a free question in a channel. Discord wins when the question is about your own code or setup, because a human can ask you what you tried. It also wins when you do not know what to ask, which the button cannot help with either. Explain wins on the questions in this post: the why behind a line the teacher glossed over, at 11pm, in ninety seconds. It has no idea whether your own project is broken. ## Limits I ran into The in-lesson dialog is a stripped-down version of the web composer. There is no teaching style menu, so you cannot ask for TLDR or Professor here. There is no attach button, so you cannot add your own file. And there is no visibility picker in the dialog. My explainer came out Unlisted, with a PUBLISH TO COMMUNITY button on its page if I wanted to opt in. The privacy setting was changeable afterwards from the cog menu. The lesson itself also fought me a little. This scrim keeps a full-screen slide up for most of its runtime, so I could not get a screenshot of the editor with the highlighted lines. The explainer's opening code slide is the only proof the selection went through. And seeking to 9:29 marked the lesson as completed, which is harmless but worth knowing if you track your progress. ## References - [Scrimba Docs, Explain in scrims](https://docs.scrimba.com/explain/scrims?via=u42d4986) - the five pieces of context sent from a lesson and the locked-scrim rule. - [Scrimba Docs, Limits and plans](https://docs.scrimba.com/explain/limits-and-plans?via=u42d4986) - 10 explainers for life on Free, 100 a month on Pro, what counts. - [Scrimba Docs, What is Scrimba Explain?](https://docs.scrimba.com/explain/introduction?via=u42d4986) - the slide-plus-narration format. - [Scrimba Docs, Going deeper](https://docs.scrimba.com/explain/going-deeper?via=u42d4986) - Go deeper and follow-ups each spend one explainer. - [Learn RAG, Chunking text from documents](https://scrimba.com/learn-rag-c033/~0b?via=u42d4986) - the lesson used for the test (Pro). - [Why Chunking Matters for RAG](https://scrimba.com/explain/guide0ab07v8g9) - the explainer the button produced, 1:31. - [Scrimba Explain: the reference page](https://scrimbaguide.tech/docs/how-it-works/scrimba-explain/) and the [tested review](https://scrimbaguide.tech/blog/scrimba-explain-review/) on this site. **Q: Where is the Explain button in a Scrimba lesson?** At the top right of the scrim header, next to the volume and layout controls, labelled EXPLAIN. Its tooltip reads Explain this to me. Clicking it pauses the scrim and opens a dialog with one text input and a CREATE EXPLAINER button. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/scrims?via=u42d4986) **Q: What does the Explain button send to the AI?** The scrim title and course, every file in the editor, any code you highlighted, the teacher's narration up to the point where you paused, and the paused moment. You only type the question. Highlighted code becomes the focus of the explainer. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/scrims?via=u42d4986) **Q: Does pressing Explain in a lesson use up an explainer?** Yes. Each press counts against the same allowance as the web tool: 10 explainers for the life of a free account, 100 a month on Pro. Follow-ups and Go deeper each spend one more. Watching an explainer you already created is free. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/limits-and-plans?via=u42d4986) **Q: Where does the explainer appear?** In my test it played as an overlay on top of the paused scrim in the same tab, and the URL gained an explain segment. The lesson sidebar gained an Explainers entry with the timestamp where I pressed the button, and the explainer also has its own standalone page with a Back to lesson link. **Q: Can I pick a teaching style or attach a file from inside a lesson?** No. The in-lesson dialog has a single text input and no style menu, attach button or visibility picker. Those options exist in the web composer at scrimba.com/explain. Write the audience and format you want into the question instead. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/teaching-styles?via=u42d4986) **Q: Is an explainer made from a lesson public?** Mine came out Unlisted, meaning anyone with the link can watch it but it is not listed in the community feed. The page offered a Publish to community button to opt in, and the privacy setting can be changed later from the cog menu in the player. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/visibility-when-creating?via=u42d4986) **Q: Does the Explain button work on free courses?** It works on any scrim you can open while signed in. It is hidden on scrims locked for your plan, so on a free account you can use it on the free courses but not on Pro-only ones like Learn RAG. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/scrims?via=u42d4986) **Q: Should I press Explain or ask in the Scrimba Discord?** Ask the Discord when the problem is your own code, error or setup, or when you do not know what to ask. Basic Discord access is free and Pro adds the Pro-only channels. Press Explain for the why behind a specific line or config value in the lesson, where the answer is in the transcript and the files. ## Try the button on a free lesson first A free Scrimba account includes 10 explainers and the free courses, so you can test the in-lesson button before deciding whether the Pro quota matters to you. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # What Is Scrimba Explain? The AI Explainer, Tested (2026) Source: https://scrimbaguide.tech/blog/scrimba-explain-review/ Scrimba Explain turns a question into a short narrated video explainer, complete with diagrams, code walkthroughs and, most of the time, a quiz at the end. A free Scrimba account gets 10 explainers for life, Pro gets 100 a month, and it works in the browser, inside Scrimba lessons, in ChatGPT, and inside coding agents like Claude Code through MCP. Most AI coding tools compete to write your code faster. This one explains it. There is a kind of stuck that no course fixes. You have read the syntax three times. You can reproduce the example. You still could not say out loud why it works, and you know that asking the question properly would take longer than pretending you understood. Scrimba's own documentation uses that exact reader as its example prompt: "I understand the syntax, it's the 'why' I'm missing." Another one: "why does a closure still see a variable after the function returned? I know Python but not JS, show me a diagram." Neither of those is a beginner. Both are people mid-way through learning something, which is where most of us spend most of our time. That is who this tool is for first. Everything else it does is downstream of that. Tested on the web, in the Chrome extension and in Claude Code through MCP with a free Scrimba account, September 2026. The screen recordings below are mine. ## How Scrimba Explain works You type a question and get back a short video that explains it, narrated, with visuals built for the answer rather than stock footage. The docs put it in one line: "Ask a question, and get a narrated video lesson back, built while you watch." Here it is answering "What happens when you type a URL into the browser?". A few seconds after pressing Explain, a narrated explainer called "How a URL becomes a website" starts playing. Your browser cannot play this video. It shows a prompt being typed into Scrimba Explain and the generated video explainer playing back. [Download the recording (MP4)](https://scrimbaguide.tech/video/scrimba-explain-demo.mp4). The first 30 seconds of a 57-second explainer. Captions are available in the player. Transcript and on-screen description On screen: The Scrimba Explain home page. The question "What happens when you type a URL into the browser?" is typed into the prompt box and Explain is pressed. A generating screen appears, then a narrated explainer titled "How a URL becomes a website" starts playing. It moves to a slide titled "The internet's address book", where an animated diagram connects a browser, a DNS address book and a website server, and then to a slide titled "The request and response". Narration: What happens when you type a URL into your browser? Think of the internet like a massive phone system. Your browser knows the name you typed, like example.com, but it needs a phone number, called an IP address, to actually call the server. It asks a DNS server, which acts like an address book, to swap that name for a number. Once the browser has the address, it reaches out to the server. They start with a TCP handshake, which is just a way of saying "Are you there?" and "Yes, I'm ready." Only then does the browser send a GET… The explainer is built slide by slide for that question: a title card, an animated diagram of the browser asking DNS for an address, a request-and-response walkthrough, a numbered breakdown of how the browser builds the page, and a multiple-choice question at the end. The docs are firm about the distinction: "An explainer is not a screen recording. Each slide is real, typed content." There are five ways in: | Entry point | What it does | | --- | --- | | Web | Type a question at `scrimba.com/explain`, get a video back | | Inside a lesson | Press EXPLAIN in a scrim's header and ask about the code in front of you; the lesson, your highlighted lines and the teacher's transcript go in as context | | ChatGPT | Mention `@Explain` in a conversation and the answer arrives as a video | | Chrome extension | Turn any article or page you are reading into an explainer | | Claude Code / Codex (MCP) | Connect it to your coding agent through MCP, the standard way agents plug into outside tools, and get a walkthrough of your actual code | ## If you are learning: it answers the question you cannot phrase A chat window drifts. You ask for the simple version, and three replies later you are reading about edge cases. Explain lets you pick the level up front, and the whole video stays at it. Scrimba ships several teaching styles: | Style | What it does | | --- | --- | | Explain | The default. "Simple words, small steps", built on concrete examples | | Standard | Clear, well-rounded teaching | | TLDR | A few slides. The core insight instead of a full lesson | | Professor | "Maximum depth, down to the bytes": real memory, wire formats, engine behaviour | | LOL | "Funny and sarcastic, still accurate" | | Per and Tom | Scrimba's founder and Tom Chant, in their own teaching voices | `Professor` is the one that tells you who else they are building for, but `Explain` and `TLDR` are the two a learner will live in. TLDR is for the moments you do not want a lesson, just the one sentence that makes the rest click. The other thing worth knowing if you are not learning in English: explainers are narrated in 33 languages, with a native voice for each. I learned to code in my second language and I underrate how much friction that adds until something removes it. My rule: let it explain something you have already tried to understand and failed. Not the first thing that meets a new topic. The order decides whether it builds the muscle or replaces it, and nothing in the tool enforces that for you. This is the same argument I make about AI generally in [how to learn coding without depending on it](https://scrimbaguide.tech/blog/how-to-learn-coding-without-depending-on-ai/). ## If you are a junior: it is for the code you did not write The second audience is the one starting a first job, and the problem there is different. The concepts are usually fine. What is not fine is forty thousand lines of someone else's code and three days to find your way around it. I do not think you can read an entire codebase as a solo developer or on a team of three. Nobody can. You cannot read every pull request line by line either, and neither can anyone else on the team, which is why code quietly gets merged that nobody has really read. Scrimba reached the same conclusion. They attach an Explain video to every pull request in their own codebase. Per describes it as starting with a high-level overview and then digging into the details, so the team can stay on top of what is changing. Through MCP, the prompts their docs suggest are exactly the ones a new hire needs: - "Walk me through how authentication works in this codebase" - "Explain what this branch changes and why" - "Explain the bug we just fixed and how" The output is grounded in your actual files, because your agent does the research and Explain renders it. That is what separates it from a generic illustration of the concept. Here is that flow on the Express source code. Asked for a short explainer of what `res.send` does in `lib/response.js`, Claude Code reads the file, calls Explain, and hands back a link that renders while it works. Your browser cannot play this video. It shows Claude Code reading lib/response.js from the Express repository, calling Scrimba Explain through MCP, and the resulting explainer opening. [Download the recording (MP4)](https://scrimbaguide.tech/video/scrimba-explain-claude-code.mp4). Claude Code connected to Explain through MCP, sped up while it builds the explainer. Captions are available in the player. Transcript and on-screen description On screen: A terminal running Claude Code in the Express repository. The prompt "Make a short explainer video of what res.send does in lib/response.js. Keep it brief." is typed and submitted. Claude Code reads lib/response.js, calls scrimba-explain and replies with a link to the explainer, which renders while it builds. This part plays sped up six times. The browser then opens the finished explainer, titled "Express res.send() Internals", which moves to a flowchart titled "What send() does" and a code slide titled "Branching on body type". Narration: …turns whatever you hand it into a finished HTTP response. The flow branches on the type of the body. A string just gets a charset, while a plain object is handed off to res.json instead of being sent directly. Everything else moves on to compute Content-Length and an ETag, before the final status check decides whether the body actually gets sent. This switch is the entry point. A string falls back to Content-Type HTML, unless one is already set, in which case Express only adds a UTF-8 charset. A null body becomes an empty string, a Buffer-like value gets Content-Type bin… One detail explains a lot: explainers made through MCP are private by default. ChatGPT ones are unlisted. So the entire developer half of this product is invisible to everyone outside the team using it, which is why the public side of Explain looks like a general learning tool and the developer side looks like a rumour. If you are heading into a first role, this pairs with [reading code, the skill AI coders skip](https://scrimbaguide.tech/blog/how-to-get-better-at-reading-code-2026/), and with the general reality of [the junior job market in 2026](https://scrimbaguide.tech/blog/junior-developer-job-market-2026/): writing code is the cheap part now, and being able to explain it is what gets noticed. ## The Chrome extension: explain the page you are reading You hit the extension icon on a dense technical article. There is no popup: the extension reads the page, opens the explainer in a new tab, and it starts building while you watch. Here it is on MDN's guide to using promises, a page plenty of JavaScript learners bounce off the first time. Your browser cannot play this video. It shows the Explain extension turning MDN's Using promises guide into a narrated video explainer. [Download the recording (MP4)](https://scrimbaguide.tech/video/scrimba-explain-extension.mp4). The extension is available for Chrome. The clip shows the click, the explainer generating and its first half minute. Captions are available in the player. Transcript and on-screen description On screen: MDN's "Using promises" guide is scrolled briefly, then the Explain extension icon in the browser toolbar is clicked. A new tab opens and a narrated explainer titled "Using JavaScript Promises" starts playing. It moves to a slide titled "What is a Promise?" and then to a side-by-side code comparison titled "From Callbacks to Promises". Narration: Promises are the standard way to handle asynchronous tasks in JavaScript, moving us away from messy callback functions. A promise is an object that stands in for a future result. The fundamental shift is that functions now return this object immediately, and you attach your success or failure logic to it later. The difference is striking. Callback hell forces deep nesting and repetitive error handling. The promise chain flattens the logic, allowing you to catch all errors in one place at the end. A long reference page became a one-minute walkthrough: what a promise is, a diff that turns nested callbacks into a promise chain, the async/await version with the code view highlighting each line as it is narrated, running several promises at once, and wrapping an old callback API. The on-screen pointer does the talking-through. Scrimba's own demo of the extension also draws mermaid diagrams. Per pitches this for articles you "kind of don't have the patience or the energy to go through" right now, rather than ones you cannot understand. Most evenings, that is the actual problem. Many explainers end with a quiz. Summaries, tasks on your own code and the TLDR style skip it. Scrimba's docs say page explainers from the extension skip it too, though the closing quiz in their own extension demo suggests that rule is not firm. When it is there, it is a small detail doing heavy lifting. The failure mode of every explanation tool is that watching feels like learning. A question at the end is the cheapest possible defence against that. ## What people use Scrimba Explain for besides code The docs list eleven use-case domains, and only two of them are software. The others include healthcare ("Cardiac Prescription Logic"), finance, real estate, automotive, philosophy, and care and admin ("Navigating Elder Care in the UK"). Per's own launch demo generates a driving test briefing for a driving instructor's students. The public community feed said the same thing louder at launch, with entries like Algebra Basics, The Sky in Norwegian and Why We Get Hiccups. By 20 September 2026 it had tilted technical and multilingual: AWS EBS Explained, Mastering Array.reduce, a five-part Getting Started with RAG playlist, C# Design Patterns, plus French entries next to the puppy training and grammar explainers. The Featured tab Scrimba curates still leans general (The Offside Rule, Newton's First Law, The Magic of Nursing). So Scrimba built a general learning tool, and the coding integration is the specialised half. For you, that means a free tool you will end up using outside programming too, which is worth more than a narrow one you open twice. ## How to get Scrimba Explain, and is it free? Two steps: create a free Scrimba account, then install the plugin in your coding agent if you want the repository side. The [Explain hub](https://scrimba.com/explain?via=u42d4986) links out to the ChatGPT app, the Chrome Web Store listing and Scrimba's Claude Code docs. Codex has no card of its own there. It uses the same @Explain Video Generator plugin as ChatGPT, either from Codex inside the ChatGPT desktop app or from the Codex CLI plugin browser. Only the Codex IDE extension needs the MCP endpoint at `scrimba.com/explain/mcp`, the same one any other MCP-capable agent uses. The Chrome extension is a separate install and needs no agent at all. The "free during open beta" line from the launch is gone. The [limits page](https://docs.scrimba.com/explain/limits-and-plans?via=u42d4986) now gives a free account 10 explainers for life (they do not renew) and a Pro account 100 a month. Follow-up questions and Go deeper each spend one. Drafts made from ChatGPT or a coding agent are free until you open the link and claim them, and redoing, regenerating or exporting an existing explainer costs nothing. The launch numbers were 20,000 explainers on 13 August; by 20 September the hub listed 150 Featured, 516 Community and 191 Playlist entries in its public tabs. The free tier is an acquisition funnel, and Per says so himself at the end of the Chrome extension video: it is free but you need an account on scrimba.com, "which is a learning platform that we are building". Ten lifetime explainers is enough to find out whether the format works for you and not enough to study with. Whether the 100 a month tips you into Pro depends on everything else Pro includes, which our [Pro vs Free breakdown](https://scrimbaguide.tech/docs/pricing/pro-vs-free/) covers, and the [reference page on Explain](https://scrimbaguide.tech/docs/how-it-works/scrimba-explain/) has the full limits table. ## The EXPLAIN button inside Scrimba lessons There is a fifth entry point the launch coverage skipped and I nearly missed: an EXPLAIN button in the header of every scrim, next to the timeline. Click it, type what you want explained, and Scrimba builds an explainer using the lesson as context. What gets sent is the lesson title, the files in the editor, any code you have highlighted, the teacher's transcript, and the point where you paused. The result opens in the scrim sidebar, counts toward your 10 or 100, and needs a signed-in account, so it does not work on locked scrims. [Scrimba's page on Explain in scrims](https://docs.scrimba.com/explain/scrims?via=u42d4986) has the details. ![Scrimba Explain open inside a Learn JavaScript lesson: a dialog asks what to explain, beside the scrim editor and its EXPLAIN button.](https://scrimbaguide.tech/img/guides/scrimba-explain-lesson-modal.webp) *The EXPLAIN button sits in the scrim header. Highlight a line first and the explainer focuses on it.* Screenshot of scrimba.com, taken by scrimbaguide.tech. One naming quirk will save you a confused search. In ChatGPT's plugin directory the same product is listed as Explain Video Generator, not Scrimba Explain. I stepped through exactly what one of these lesson explainers produces, slide by slide, on a [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) lesson, in [a full walkthrough of the EXPLAIN button](https://scrimbaguide.tech/blog/scrimba-explain-inside-courses/). ## The limits of Scrimba Explain ### The output is only as good as the research behind it With MCP, that research is your agent's work rather than Scrimba's. A vague question against a repository your agent has not properly explored produces a confident, well-narrated, shallow video. The production values do not drop when the substance does, and in a learning tool that is a real risk. ### The free quota does not renew Ten explainers for life, on the free account, is a trial rather than an allowance. Each follow-up and each Go deeper spends one, so a single curious evening can use half of it. Treat the free tier as a way to test the format, and plan any regular use around the Pro quota or around the agent drafts, which stay free until you claim them. ### It answers questions but does not plan your learning Scrimba never pitches Explain as a course. The limit is subtler than that: it answers questions you already know to ask. It cannot tell you what you do not know, and it never makes you write anything. Those are the jobs the 81.6-hour, 13-module [Frontend path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) and the 108.4-hour, 20-module [Fullstack path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) do instead, building toward a portfolio project rather than a quiz. Explain does not overlap with either. ## The bottom line If you are learning, this is the closest thing I have used to a tutor you can interrupt. Point it at the concept you have already failed to understand once, pick TLDR when you want the insight and Explain when you want the lesson, and take the quiz seriously. If you are junior and drowning in a codebase, the MCP integration is the strongest thing here, and few people ever see it because those explainers are private by default. Whether it helps depends on a habit the tool cannot enforce. Use it on something you have already wrestled with and it works like a tutor. Use it to skip the wrestling and you start leaning on it, the kind of reliance behind the 20% of developers in the Stack Overflow 2025 survey who report less confidence in their own problem-solving. I use it. I just use it second. If you already lean on NotebookLM for narrated video summaries of your own documents, see [how Explain compares to NotebookLM Video Overviews for learning code](https://scrimbaguide.tech/blog/scrimba-explain-vs-notebooklm-video-overviews/). ## References - [Scrimba Docs, What is Scrimba Explain?](https://docs.scrimba.com/explain/introduction?via=u42d4986) - the one-line definition, the "not a screen recording" distinction, and 33-language narration. - [Scrimba Docs, Writing a good prompt](https://docs.scrimba.com/explain/prompting?via=u42d4986) - the "I understand the syntax, it's the 'why' I'm missing" and closure example prompts. - [Scrimba Docs, Teaching styles](https://docs.scrimba.com/explain/teaching-styles?via=u42d4986) - Explain, Standard, TLDR, Professor, LOL, Per and Tom, with their exact descriptions. - [Scrimba Docs, Use cases](https://docs.scrimba.com/explain/use-cases?via=u42d4986) - the eleven domains, including healthcare, finance, real estate and elder care. - [Scrimba Docs, Privacy and sharing](https://docs.scrimba.com/explain/privacy-and-sharing?via=u42d4986) - MCP explainers private by default, ChatGPT explainers unlisted. - [Scrimba Docs, Claude Code](https://docs.scrimba.com/explain/claude-code?via=u42d4986) - the install command and the suggested repository prompts quoted above. - [Scrimba Docs, ChatGPT and Codex](https://docs.scrimba.com/explain/chatgpt-codex?via=u42d4986) - the @Explain Video Generator plugin route for ChatGPT and Codex, and the MCP fallback for the Codex IDE extension. - [Introducing Explain by Scrimba](https://www.youtube.com/watch?v=k6rbHmBxSEs) - the pull request practice, the driving instructor example, and 20,000 explainers as of 13 August 2026. - [Turn Complex Articles into Videos with Explain in Chrome](https://www.youtube.com/watch?v=JW6trsvl7HA) - the extension walkthrough, the mermaid diagrams and closing quiz, and the free account framing. - [Scrimba on Product Hunt](https://www.producthunt.com/posts/scrimba-explain) - the 13 August 2026 launch. - [Scrimba Docs, Limits and plans](https://docs.scrimba.com/explain/limits-and-plans?via=u42d4986) - 10 explainers for life on Free, 100 a month on Pro, what counts and what is free. - [Scrimba Docs, Explain in scrims](https://docs.scrimba.com/explain/scrims?via=u42d4986) - the in-lesson EXPLAIN button and what it sends as context. - [Stack Overflow 2025 Developer Survey, AI](https://survey.stackoverflow.co/2025/ai) - 20% reporting decreased confidence in their own problem-solving. **Q: What is Scrimba Explain?** It turns a question, article, document or codebase into a short narrated video explainer with diagrams, code walkthroughs and, in most cases, a closing quiz. You can use it on the web, from the EXPLAIN button inside a Scrimba lesson, through the Chrome extension, by mentioning @Explain in ChatGPT, or from a coding agent like Claude Code via MCP. Unlike most AI coding tools it does not write code, it explains things that already exist. **Q: Is Scrimba Explain free?** Partly. A free Scrimba account gets 10 explainers for life, and they do not renew. Pro accounts get 100 a month. Follow-ups and Go deeper each count as one, while explainers drafted from ChatGPT or a coding agent are free until you open and claim them, and redoing or exporting an existing one is free. Ten is enough to test the format, so try it before deciding whether the Pro quota matters to you. **Q: Is Scrimba Explain only for programmers?** No. Scrimba's own documentation lists eleven use-case domains and only two are software, with the rest covering healthcare, finance, real estate, philosophy and elder care among others. The public community feed launched heavy on non-coding topics like algebra, languages and biology, and by September 2026 had shifted toward technical entries, with the curated Featured tab still leaning general. The developer features are one half of the product, not the whole of it. **Q: How is Explain different from asking ChatGPT?** The output format and the grounding. You get a narrated video with diagrams, a code view and usually a quiz rather than a wall of text, and you can pick a teaching style so the explanation stays at your level. With MCP, your coding agent researches your actual files first. It is not a text-to-video model and uses no avatars or stock footage. In ChatGPT's plugin directory it is listed as Explain Video Generator. **Q: Can Scrimba Explain explain my own codebase?** Yes, through MCP. Connect it to Claude Code, Codex or any MCP-capable agent and it builds the walkthrough around code in your repository rather than a generic example. Those explainers are private by default, which is why this side of the product is largely invisible. Scrimba attaches one to every pull request in their own codebase. **Q: How do I use Scrimba Explain with Claude Code?** Add it as an MCP server with claude mcp add --transport http scrimba-explain https://scrimba.com/explain/mcp, then ask for an explainer in plain words, such as 'make an explainer of what this branch changes'. Claude Code reads your files, calls Explain and returns a link that renders while it builds. The explainer is private by default, and opening the link claims it to your free Scrimba account. **Q: Should I use Explain instead of reading the code myself?** No, and that order matters more than anything else in this review. Use it on something you have already tried to understand and failed, where it works like a tutor. Use it as the first thing that meets a new topic and it replaces the struggle that builds skill, since a polished narrated explanation produces a strong feeling of understanding whether or not the understanding is there. ## Try the format before you weigh a subscription Explain needs only a free Scrimba account, and the free courses are a better test of whether interactive learning suits you than any feature list. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # Scrimba Explain vs NotebookLM Video Overviews for Learning Code (2026) Source: https://scrimbaguide.tech/blog/scrimba-explain-vs-notebooklm-video-overviews/ Scrimba Explain turns a typed question into a narrated video with code, diagram and quiz slides in about ten seconds. NotebookLM Video Overviews turn documents already sitting in a notebook into a narrated slideshow that can take over 30 minutes. Pick Explain for a coding concept or a piece of code, NotebookLM for a video summary of your own PDFs or notes. I generated every Explain result in this comparison myself, on a Pro account: the explainers, the transcripts, the quizzes. NotebookLM sat behind a corporate sign-in on the machine I had, so its side of the table comes from Google's own help pages and blog posts, linked where it appears, and anything Google does not document is marked unverified. ## What each tool is Scrimba Explain is the AI explainer feature on [scrimba.com/explain](https://scrimba.com/explain?via=u42d4986). You type a question, optionally paste code or attach a file, and it builds a short narrated lesson from typed slides while you watch. The [Scrimba Explain review](https://scrimbaguide.tech/blog/scrimba-explain-review/) covers what it is like to use; the [reference page](https://scrimbaguide.tech/docs/how-it-works/scrimba-explain/) has the full quota and entry point tables. I will not repeat either here. NotebookLM is Google's research notebook. You add sources (PDFs, Docs, slides, web pages, YouTube links, audio) and ask questions grounded in them. A Video Overview is one of its Studio outputs: Google describes it as narrated slides that pull "images, diagrams, quotes and numbers from your documents", launched in July 2025 as the visual sibling of Audio Overviews ([Google blog](https://blog.google/innovation-and-ai/models-and-research/google-labs/notebooklm-video-overviews-studio-upgrades/)). Google's help centre now calls the product Gemini Notebook on some pages, though the app still lives at notebooklm.google.com. Explain starts from a question. NotebookLM starts from a pile of sources. Most of the table below follows from that. ![Scrimba Explain, comparison diagram: two flowcharts contrasting the Explain and NotebookLM Video Overview build steps.](https://scrimbaguide.tech/img/blog/scrimba-explain-vs-notebooklm-video-overviews/input-to-video.webp) *Explain is prompt first; NotebookLM is source first. Build time is the other gap: seconds on one side, potentially half an hour on the other.* Diagram by scrimbaguide.tech. NotebookLM timings from Google's help page. ## Comparison table Every NotebookLM cell below is taken from Google's documentation. Where Google is silent, the cell says so. | Feature | Scrimba Explain | NotebookLM Video Overviews | | --- | --- | --- | | Input types | Typed question; pasted code; attached code files, Markdown, PDFs, images, Jupyter notebooks; a web page (Chrome extension); a repository (MCP) | Notebook sources: Docs, Word, PDF, text, Markdown, Slides, Sheets, audio, images, YouTube URLs, web URLs, ePub, CSV, pasted text (help page) | | Code slides | Yes, a first class slide type. My context window explainer (below) got a chatUtils.js slide with a working trimHistory function | Not documented. Google lists images, diagrams, quotes and numbers from your sources; code is not mentioned (unverified) | | Diagram slides | Yes, on request. The same explainer drew a User / App State / LLM sequence diagram | Yes, diagrams pulled from your sources; Google does not document drawing new ones (unverified) | | Quiz | When you ask for one in the prompt. One multiple choice question at the end (TLDR style and extension explainers skip it) | Not inside the video as documented. Quizzes and flashcards are a separate Studio output | | Languages | 33 narration languages | 80 plus (80 listed for Explainer format, 73 for Short, as of September 2026); Cinematic is English only | | Length and build time | Most run 40 seconds to 2 minutes; mine was playable about 10 seconds after submit | Short format (called Brief at launch) is about 60 seconds; Explainer length not published; generation can take over 30 minutes (help page) | | Export format | MP4 at 2560x1440 and 60 fps plus a .vtt captions file; Public or Unlisted only | Download as a local video file; Play Books sources can block it; resolution not published | | Free quota | 10 explainers for the life of a free account; 100 a month on Pro | 3 Video Overviews a day on the free plan; 20 a day on Pro; 200 a day on Ultra | | Sharing defaults | Public by default on the web hub (picker in the composer); Unlisted from ChatGPT; private draft from MCP | Share a link after confirming notebook sharing, or share the whole notebook; default state of a fresh overview not documented (unverified) | | Agent and MCP integration | Yes: MCP endpoint for Claude Code, Codex and other agents, plus a ChatGPT plugin and a CI endpoint for pull requests | None documented for Video Overviews (unverified) | [Visit NotebookLM Video Overviews](https://support.google.com/notebooklm/answer/16454555) Sources for the NotebookLM column: the [Video Overviews help page](https://support.google.com/notebooklm/answer/16454555), the [source types page](https://support.google.com/gemininotebook/answer/16215270), the [plan limits page](https://support.google.com/notebooklm/answer/16213268) and Google's [languages announcement](https://blog.google/technology/google-labs/notebook-lm-audio-video-overviews-more-languages-longer-content/). Sources for the Scrimba column: my own explainers plus [limits and plans](https://docs.scrimba.com/explain/limits-and-plans?via=u42d4986), [languages](https://docs.scrimba.com/explain/languages?via=u42d4986) and [exporting](https://docs.scrimba.com/explain/exporting?via=u42d4986) in Scrimba's docs. ## Where NotebookLM wins Your own corpus. If the thing you want explained is a 90 page PDF, six lecture recordings and a Google Doc of notes, NotebookLM is built for that. A free notebook takes up to 50 sources, each up to 500,000 words or 200 MB ([source limits](https://support.google.com/gemininotebook/answer/16215270)). Explain accepts attachments too, but Scrimba pitches it as a question answering tool, and I would not hand it a semester of material. Languages. Google's help page lists 80 languages for the Explainer format against Scrimba's 33. If you learn in Tamil or Ukrainian both are covered; if you learn in Swahili, only NotebookLM is. Daily renewal. The free plan gives 3 Video Overviews a day, reset every 24 hours ([plan limits](https://support.google.com/notebooklm/answer/16213268)). Scrimba's free 10 never renew. Over a month of light use, the NotebookLM free plan gives you more videos. Visual variety. Google offers eight illustration styles (Classic, Whiteboard, Watercolor, Retro Print, Heritage, Paper-craft, Kawaii, Anime) and a Cinematic format built with Veo 3 for Ultra subscribers ([styles](https://blog.google/innovation-and-ai/models-and-research/google-labs/video-overviews-nano-banana/), [Cinematic](https://blog.google/innovation-and-ai/products/notebooklm/generate-your-own-cinematic-video-overviews-in-notebooklm/)). Explain lets you name an art style for its images, but the product is not about looking good. ## Where Scrimba Explain wins Code on screen. This is the one that decides it for programmers. When I asked for "one short JavaScript snippet that trims the history to a token budget", the result was a `chatUtils.js` slide with a `trimHistory(messages, tokenLimit)` function that the narration walked through line by line. Google's own description of Video Overviews never mentions code, and nothing in the help pages suggests a syntax highlighted code slide exists. I could not check, so treat that as unverified, but the absence in the docs is telling. Speed. The context window explainer was playable about ten seconds after I pressed the button. Google warns that a Video Overview "may take a while" and "sometimes, more than 30 minutes" ([help page](https://support.google.com/notebooklm/answer/16454555)). If you are stuck mid lesson, ten seconds keeps you in the lesson; thirty minutes does not. The quiz. Every one of my explainers ended with a quiz slide, usually headed "Test your knowledge" (one Professor run called it "Your turn", and one playlist lesson "Test your strategy"): one question, three or four answers, gold for a first try. NotebookLM has quizzes, but as a separate Studio item, not inside the video. For retention that matters, because the question arrives while the explanation is still in your head. Your repository. Explain has an MCP endpoint (MCP is the open protocol coding agents use to call outside tools) that lets Claude Code or Codex write a lesson about the branch you are reading. Google documents nothing like this for Video Overviews. Scrimba also teaches the protocol itself: Maham Codes's [Intro to MCP](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/) is 17 scrims in which you build a weather MCP server in Node.js and TypeScript, the same connective tissue Explain's endpoint runs on. Embedding and Public sharing. Explain gives you an iframe embed and a Public community feed. That default cuts both ways, which the sharing row in the table shows, but it means a good explainer can be dropped into a README or a blog post. ## The same prompt, both tools This is the section I most wanted to write with two screenshots side by side, and could not. Here is what I can offer: the full Explain result, and what Google's documentation says would happen if you fed the same brief to NotebookLM. The prompt I used, Standard teaching style, on the web hub: What is a context window, why do LLMs seem to forget the start of a long conversation, and what can a developer do about it? For a web developer building a chat app in JavaScript who sends the whole message history on every request. Cover tokens versus characters, what happens when the history exceeds the limit, and the two common fixes: a sliding window and summarising older turns. Show one short JavaScript snippet that trims the history to a token budget before the API call. Include one diagram slide showing the window filling up turn by turn, and finish with a quiz. ### What Scrimba Explain produced The explainer is at [scrimba.com/explain/guide0jc32sm3l](https://scrimba.com/explain/guide0jc32sm3l), titled "Managing the LLM Context Window", 1 minute 22 seconds, and it is embedded here so you can watch it before reading my notes on it. Its transcript has six sections: Managing the LLM Context Window, Tokens vs. Characters, The window filling up, Handling the limit, Implementing a sliding window, and Test your knowledge. The Explain side of the comparison, 1:22, Standard style: sequence diagram, trimHistory code slide and a quiz.[Open on scrimba.com](https://scrimba.com/explain/guide0jc32sm3l) Three slides matter. The diagram slide shows a User, App State and LLM sequence with the window filling turn by turn, exactly what I asked for. The code slide, `chatUtils.js`, holds a `trimHistory(messages, tokenLimit)` function that drops the oldest messages until the estimate fits, using the rough four characters per token heuristic. The quiz asks what happens when the history exceeds the limit; the correct answer is that the API returns an error, which is right. What it skipped: the prompt asked why models "seem to forget" the start of a conversation, and the explainer only covered truncation and overflow. It said nothing about attention degrading in the middle of long contexts. Fair for 82 seconds, but a Professor style run might have gone there. The screenshot below is a different explainer from the same batch, on RAG in Professor style, because it shows the transcript layout more clearly than the context window one. ![Scrimba Explain, finished explainer page: a video player above a headed transcript about how RAG works.](https://scrimbaguide.tech/img/blog/scrimba-explain-vs-notebooklm-video-overviews/explain-professor-style-rag-explainer-transcript.webp) *Every Explain result page has the transcript as headed prose under the player, so you can check what the narration claimed before you trust it.* ### What NotebookLM's docs say you would get You cannot type that prompt into an empty notebook. Video Overviews need at least one source, so step one is adding something: a blog post on context windows, an API reference page, or your own notes. Then, in Studio, you choose Video Overview, pick a format (Cinematic, Explainer or Short, which Google's launch post called Brief), a language and a visual style, and pick a suggested topic or type a custom one ([help page](https://support.google.com/notebooklm/answer/16454555)). The output would be a narrated slideshow drawing on the sources you added. Whether it would contain a JavaScript slide is the open question, and Google does not answer it. A diagram is plausible if one of your sources contains one. A quiz inside the video is not something Google documents; you would generate the quiz separately in Studio. And you would wait: minutes at best, more than thirty at worst. "Same prompt, both tools" only works for one of them. NotebookLM's steering prompt shapes a summary of what you already gave it. Explain's prompt is the whole input. ![Scrimba Explain, composer screen: a typed prompt with the teaching style menu open showing several voice options.](https://scrimbaguide.tech/img/blog/scrimba-explain-vs-notebooklm-video-overviews/explain-composer-teaching-style-menu.webp) *The style menu behind the Explain button. NotebookLM's equivalent is a visual style picker plus a steering prompt; it has no teaching voice options.* ## Who should use which Pick Scrimba Explain if you are learning to code and the thing you are stuck on is a concept, a function or a diff. Code slides and a ten second turnaround are built for that moment, and the quiz catches you before you move on. It also fits anyone using Claude Code or Codex who wants a walkthrough of a branch without writing it. Ten free explainers is enough to find out whether it helps; after that you are on the Pro quota or the free agent drafts. Pick NotebookLM Video Overviews if your material already exists as documents and you want a video summary of it. Students with a folder of lecture PDFs are the obvious case, along with anyone learning in a language Scrimba does not cover. The free plan's three a day is generous for that use. Use both if you are working through Scrimba's AI courses. Guil Hernandez's [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/), 22 scrims that build a Supabase-backed movie chatbot, is the retrieval idea NotebookLM runs on every time it answers from your notebook. Arsala Khan's [Learn Context Engineering](https://scrimbaguide.tech/docs/courses/ai/context-engineering/), 15 scrims spent trimming a chat app's message history by token count, is the same problem Explain's own context window explainer (above) walks through. Bob Ziroll's [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) and Arsala Khan's [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) cover the calling side, and the 11.4-hour [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) strings all of it together. Whichever you choose, both vendors say the same thing about accuracy. Scrimba prints "Explain is AI and can make mistakes" under every player. Google says Video Overviews "may contain inaccuracies or audio glitches" ([help page](https://support.google.com/notebooklm/answer/16454555)). My context window explainer was correct but incomplete, which is the usual shape of the problem. ## Try Explain on a free Scrimba account Ten explainers, the free course modules and the Discord come with a free account. Enough to see whether narrated code slides help you before any subscription question comes up. [Try Scrimba free](https://scrimba.com/?via=u42d4986) ## References - [Scrimba Docs, What is Scrimba Explain?](https://docs.scrimba.com/explain/introduction?via=u42d4986) - definition and slide types. - [Scrimba Docs, Limits and plans](https://docs.scrimba.com/explain/limits-and-plans?via=u42d4986) - 10 explainers for life on Free, 100 a month on Pro. - [Scrimba Docs, Languages](https://docs.scrimba.com/explain/languages?via=u42d4986) - the 33 narration languages. - [Scrimba Docs, Exporting](https://docs.scrimba.com/explain/exporting?via=u42d4986) - MP4 at 2560x1440, 60 fps, .vtt captions. - [Scrimba Docs, Visibility when creating](https://docs.scrimba.com/explain/visibility-when-creating?via=u42d4986) - Public default on the web hub. - [Scrimba Docs, MCP](https://docs.scrimba.com/explain/mcp?via=u42d4986) - the agent endpoint. - [Managing the LLM Context Window](https://scrimba.com/explain/guide0jc32sm3l) - the explainer generated for this article, 1:22, Standard style. - [Google, Video Overviews help page](https://support.google.com/notebooklm/answer/16454555) - formats, styles, generation time, sharing and download, accuracy notice. - [Google, Source types and limits](https://support.google.com/gemininotebook/answer/16215270) - accepted sources, 500,000 words or 200 MB per source. - [Google, Plan limits](https://support.google.com/notebooklm/answer/16213268) - 3 Video Overviews a day on the free plan, 20 on Pro, 200 on Ultra. - [Google blog, Video Overviews launch](https://blog.google/innovation-and-ai/models-and-research/google-labs/notebooklm-video-overviews-studio-upgrades/) - July 2025 launch and the "images, diagrams, quotes and numbers" description. - [Google blog, More languages](https://blog.google/technology/google-labs/notebook-lm-audio-video-overviews-more-languages-longer-content/) - 80 languages for Video Overviews. - [Google blog, Nano Banana styles](https://blog.google/innovation-and-ai/models-and-research/google-labs/video-overviews-nano-banana/) - six of the visual styles; the [help page](https://support.google.com/notebooklm/answer/16454555) lists all eight. - [Google blog, Cinematic Video Overviews](https://blog.google/innovation-and-ai/products/notebooklm/generate-your-own-cinematic-video-overviews-in-notebooklm/) - Cinematic format, English only, Ultra plan. **Q: Is Scrimba Explain or NotebookLM better for learning to code?** Scrimba Explain, for most coding questions. It renders code and diagram slides from a typed prompt, builds in about ten seconds and can end with a quiz when you ask for one. NotebookLM Video Overviews summarise documents you have already added to a notebook, and Google does not document code slides for them. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/introduction?via=u42d4986) **Q: Can NotebookLM make a video from a question alone?** Not as documented. A Video Overview is generated from the sources in a notebook, so you add at least one source first and then use a steering prompt to focus it. Scrimba Explain works from the prompt itself, with attachments optional. Source: [Scrimba Help Centre](https://support.google.com/notebooklm/answer/16454555) **Q: How many free videos do you get on each?** A free Scrimba account gets 10 explainers for the life of the account; Pro gets 100 a month. NotebookLM's free plan allows 3 Video Overviews a day, reset every 24 hours, with 20 a day on Pro and 200 on Ultra. Source: [Scrimba Help Centre](https://support.google.com/notebooklm/answer/16213268) **Q: Which one supports more languages?** NotebookLM. Google's help page lists 80 languages for the Explainer format and 73 for Short; the Cinematic format is English only. Scrimba Explain narrates in 33 languages and keeps code and file names unchanged. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/languages?via=u42d4986) **Q: Can I download the video from both tools?** Yes. Scrimba exports an MP4 at 2560x1440 and 60 fps with a .vtt captions file, for Public or Unlisted explainers. NotebookLM has a Download option on the Video Overview, though some sources such as Play Books can block it and the resolution is not published. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/exporting?via=u42d4986) **Q: Does either tool work with Claude Code or Codex?** Scrimba Explain does, through an MCP endpoint that lets a coding agent write a lesson about your repository, plus a ChatGPT plugin. Google documents no agent or MCP integration for Video Overviews. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/mcp?via=u42d4986) **Q: Was the NotebookLM side of this comparison tested first-hand?** No. NotebookLM was behind a corporate sign-in on the machine used for this article, so every NotebookLM claim comes from Google's help centre and blog, linked in the References. The Scrimba side is first-hand, including the context window explainer linked above. Source: [Scrimba Help Centre](https://support.google.com/notebooklm/answer/16454555) **Q: Does the Explain quiz count as a separate explainer?** No. The quiz is the last slide of the explainer you already created. Follow-up questions and the Go deeper button do create new explainers and draw on the same allowance. Source: [Scrimba Help Centre](https://docs.scrimba.com/explain/limits-and-plans?via=u42d4986) --- # Scrimba for Teams: Enterprise Review (2026) Source: https://scrimbaguide.tech/blog/scrimba-for-teams/ Scrimba for Teams is Pro access plus a manager dashboard: seat assignment, per-member progress, one invoice instead of ten expense reports. It fits an engineering team that wants developers coding inside real lessons, not watching video playlists. It's a poor fit if you need LMS integration or a fixed price before you call sales. Verified against Scrimba's Teams page and this site's own path reviews, September 2026. ## Who this is for You are evaluating company-wide access, billing, and learning admin here, not a solo Pro checkout. If you're the one buying the seat for yourself, read [Scrimba Review 2026](https://scrimbaguide.tech/blog/scrimba-review/) instead. ## What the manager dashboard actually adds A personal Pro account gives you the courses. A Teams account adds visibility a manager needs and an individual account can't provide: - Seat assignment. Add or remove members as headcount changes. When an intern leaves, you reassign their seat to the next hire instead of buying a new one. - Progress tracking. See who finished which module, so a 1:1 starts with "how's the React module going" instead of "are you doing this at all." - Consolidated billing. One invoice for the team, not ten separate card charges routed through expense reports. ## The 3 use cases that justify the budget Onboarding new hires without burning senior time. Assign new frontend hires the [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/), the same 81.6-hour, 13-module track MDN reviewed and endorsed in 2024. Bob Ziroll teaches the React basics and [Advanced React](https://scrimbaguide.tech/docs/courses/react/advanced-react/) modules, 28.5 of those hours combined, and the path ends with a 5.1-hour Getting Hired module built around portfolio and interview drills, not just code. Your senior devs spend less time re-explaining `useEffect` and more time reviewing pull requests against your actual codebase. Getting existing developers building with AI, not just talking about it. The [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) runs 11.4 hours across nine modules and has a JavaScript developer building a ReAct agent by hand, a RAG search over real data, and a deploy to Render, taught mainly by Tom Chant and Arsala Khan, with Bob Ziroll, Guil Hernandez, and Per Borgen covering the remaining modules. A senior dev clears it in a weekend. That kind of applied AI fluency is not cosmetic: PwC's 2026 Global AI Jobs Barometer found a [62% wage premium for AI skills](https://www.pwc.com/gx/en/issues/artificial-intelligence/ai-jobs-barometer.html), up from 57% the year before, and levels.fyi's [AI Engineer title page](https://www.levels.fyi/t/software-engineer/title/ai-engineer) shows mainstream-employer comp clustering in the $134,000-$193,000 range. A team that skips AI upskilling is competing for that comp band with fewer qualified internal candidates. Spending "use it or lose it" L&D stipends on something developers will actually open. Most learning budgets go unspent because the content is boring. Scrimba's scrim format forces the learner to type the next line, which is a lower-friction ask than "finish this 40-hour playlist." ## Team plans and seat pricing Scrimba doesn't publish fixed Teams pricing. Plans are quote-based, and management, bulk billing, and admin controls sit on top of the same Pro subscription, so the per-seat number depends on your headcount. Live prices, including any current discount, are only accurate on Scrimba's own page: get your quote at the [Teams page](https://scrimba.com/teams?via=u42d4986). Two things worth knowing before you ask for that quote: - Bulk discounts exist for larger teams, but the threshold isn't published. - Seats float. You buy "5 seats," not 5 named people, so reassigning a seat after someone leaves doesn't require a new contract. ## Is Scrimba free or paid for teams? Paid. A handful of courses are free to sample (the [Learn React](https://scrimbaguide.tech/docs/courses/react/) and [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) basics, for instance), but the Teams product wraps Pro access, and Pro is what unlocks full paths, projects, and the Discord code-review channels your developers will actually use. There's no free tier of Teams itself. ## Frequently Asked Questions **Q: Can we integrate with our LMS?** Scrimba supports some embedding, but the interactive scrim experience runs on Scrimba's own platform. Contact Scrimba's sales team for SSO or LMS integration specifics; it isn't documented publicly. **Q: Is there a minimum seat count?** Scrimba doesn't publish a fixed minimum. Team plans are quote-based, so check the Teams page or ask sales for the current threshold. **Q: Can managers view code?** Managers see percentage-complete progress, not every line a developer writes in their sandbox, unless that developer shares the link directly. **Q: Which path should we assign first?** The Frontend Developer Path for new hires who need HTML, CSS, JavaScript, and React from zero. The AI Engineer Path for developers who already ship JavaScript and need agents, RAG, and MCP fast. ## Related Pages - [All Learning Paths](https://scrimbaguide.tech/docs/paths/) - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) - [Review: Is Scrimba Worth It?](https://scrimbaguide.tech/blog/scrimba-review/) ## Upskill your team Give your developers the only tool that lets them code inside the video. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # Scrimba's Fullstack Path: What Reviewers Actually Say (2026) Source: https://scrimbaguide.tech/blog/scrimba-fullstack-path-reviews/ Scrimba's [Fullstack Developer Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) holds a 4.9-star average across 78 Product Hunt reviews, and the ones that name it specifically call it "the way to go" for learners moving past frontend-only work. The path itself runs 108.4 hours across 20 modules, HTML through Node, Express, SQL, TypeScript, and Next.js. Reviewers praise the interactive format and the project pace; the one real gap is algorithm prep for technical interviews. ## Is Scrimba's Fullstack Developer Path good? Yes, based on both the review record and what is inside the path. Product Hunt reviewers who mention the fullstack track describe the jump from frontend as smooth, and none of the 78 reviews we checked call it a poor use of time. We went further and opened the [path itself](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) with a Pro account: 20 modules, 2,055 lessons, and builds that go beyond toy apps, a Node API, a full Express app with password hashing and sessions, and a 5.3-hour career-prep module at the end. If that scope matches what you're after, you can [start the Fullstack Developer Path](https://scrimba.com/fullstack-path-c0fullstack?via=u42d4986) and keep the same Pro subscription for every module below. ## What reviewers love ### The move from frontend feels natural Most fullstack learners came from the [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) first, and reviewers say the transition holds together: "Scrimba has been a game-changer in my web development learning journey. I started with frontend development, and now I'm excited to use it for fullstack too." "If you want to learn fullstack development I genuinely believe Scrimba is the way to go." ### The projects go past copy-paste tutorials Reviewers keep citing the volume of small, real builds: "I've been on the platform for continued learning over the past couple of months and have already learned and practiced a dozen small and useful apps." That matches what is inside the path: a Hometown Homepage solo project, a Blackjack build, a Chrome extension, then a Node API and a full Express app with authentication in the backend modules. ### The interactive format holds up for backend code Some learners doubted that pause-and-edit scrims, built for frontend, would work for server code. Reviewers say it does: "Being able to pause a video and edit the code right there has made everything click faster. The instructors explain things clearly, and the hands-on challenges really help solidify what you learn." ## What the path covers The [Fullstack Developer Path page](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) has the full 20-module breakdown with hours for each. The shape: HTML, CSS and JavaScript fundamentals first, then a short AI Engineering block, then Node.js, Databases, and a 3.9-hour Express.js module that ends in a 24-scrim authentication build, users table, bcryptjs hashing, sessions, login. React, Testing, TypeScript, and Next.js close out the technical modules, followed by the 5.3-hour Launching Your Career module. ## The one real gap Not every review is glowing. The sharpest criticism in the batch we checked, a 3-star review of the earlier [Frontend Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/), still applies to the shared foundation: "These days the FE Path is polished and much much better but it is still far from mastery and getting there given the focus is on projects (and projects do not guarantee hiring)." Projects build practical skill, not algorithm fluency. If a job you want screens with LeetCode-style rounds, pair the path with [JavaScript Interview Challenges](https://scrimbaguide.tech/docs/courses/javascript/javascript-interview-challenges/) or outside practice. The path's own interview-prep content, inside Launching Your Career, covers portfolio and behavioral rounds, not algorithms. ## Who the Fullstack Path fits - [Frontend Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) graduates expanding into backend without leaving the platform. - Career changers who want the wider hiring pool that fullstack titles open. - Beginners who want one subscription instead of stitching five courses together. - Freelancers who need to ship a complete app solo. Skip it if you only want backend (the path is still frontend-heavy in its first half), you need dedicated DevOps or cloud training (see our [DevOps learning path](https://scrimbaguide.tech/blog/how-to-learn-devops-2026/)), or you are cramming for algorithm-heavy interviews. ## Frontend vs Fullstack: which should you choose? | Factor | [Frontend Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) | [Fullstack Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) | | --- | --- | --- | | Duration | 81.6 hours | 108.4 hours | | Modules | 13 | 20 | | Backend content | None | Node, Express, SQL | | Typical pace | ~4-6 months at 10-15 hrs/wk | ~3-4 months at 12-15 hrs/wk | | Best for | Fastest route to a frontend role | Broadest single-subscription track | The [Scrimba Learning Paths](https://scrimbaguide.tech/docs/paths/) post walks through the decision in more depth. The reviews and the path agree: this is a strong pick if you want frontend and backend under one Pro subscription and you are willing to supplement algorithm prep yourself. ## Start the Fullstack Developer Path 108 hours of interactive lessons from HTML to backend deployment. Included with Scrimba Pro. [Try Scrimba free](https://scrimba.com/?via=u42d4986) ## Frequently asked questions **Q: Is Scrimba's Fullstack Developer Path worth it?** The Product Hunt reviews that name it are positive, and the path itself backs that up: 108.4 hours across 20 modules, ending in a full Express app with authentication and a 5.3-hour career-prep module. The one consistent caveat, in reviews and in the curriculum, is that project-based learning does not cover algorithm interview prep, so plan to supplement. **Q: What does the Scrimba Fullstack Developer Path cover?** 108.4 hours across 20 modules: HTML, CSS, and JavaScript fundamentals, then a short AI Engineering block, Node.js, Databases (SQL), Express.js with a full authentication build, React, TypeScript, Next.js, and a 5.3-hour Launching Your Career module. Every lesson is a scrim, pause the video and edit the code directly. **Q: How long does the Fullstack Path take to complete?** 108.4 hours of lessons. At 12 to 15 hours a week, most learners finish in 3 to 4 months; full-time learners in 6 to 10 weeks. That is about 27 hours more than the Frontend Path's 81.6 hours, the difference is the backend, database, and deployment modules. **Q: Who is the Fullstack Path best for?** Frontend Path graduates expanding into backend, career changers who want fullstack-role versatility, beginners who want one comprehensive subscription, and freelancers who build complete apps solo. Look elsewhere if you only want backend, need dedicated DevOps or cloud training, or are prepping for algorithm-heavy technical interviews. --- # Scrimba's Most Underrated Feature: Instant Practice Without Setup Source: https://scrimbaguide.tech/blog/scrimba-instant-practice-no-setup/ Open a Scrimba lesson and you are writing code in about 10 seconds: no terminal, no IDE, no `npm install`. The files, dependencies and a live mini-browser are already there. That is the platform's quietest advantage over a YouTube or Udemy tutorial. ## Who needs a zero-setup coding tool? Anyone who has ever sat down to "watch a tutorial" and lost 15 minutes to a terminal. If you want to practice inside a lesson the moment you open it, this is what that looks like on Scrimba and what it changes. ## What following a normal coding tutorial actually costs you Here is "following along" on most platforms: - Watch the instructor create a new project - Open your terminal - Run `npm create vite@latest my-project` - Wait for installation - `cd my-project && npm install` - Open VS Code - Navigate to the right file - Realize the tutorial uses an older version of React - Debug the version mismatch - Finally start coding, 15 minutes later Experienced developers shrug this off. For someone still building the habit, those 15 minutes are where motivation dies. You sit down to learn and spend a third of your session on configuration before you write a line of the code you came for. ## How does Scrimba's no-setup practice actually work? Scrimba's version: - Open browser - Click the next lesson - Start coding The environment ships pre-configured for every scrim: the files exist, the dependencies are installed, and a mini-browser renders your output as you type. Inside a lesson, purple ghosts on the timeline mark where a challenge pauses the recording for you, and the moment you start typing a scribble (a yellow dot) saves your version of the code separately from the instructor's, so you can rewind and compare. The [full mechanics of a scrim](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/) are worth reading if you want the technical picture. ### It adds up across a week Study 5 days a week and save 10 minutes of setup each time: that is 50 minutes back, close to a full extra lesson, moved from configuration into practice. ### It changes whether you start at all The setup tax is where most learners quit before the lesson begins. Your brain runs the math: "I have 30 minutes, 10 go to setup, so 20 of real learning, is that worth opening the laptop?" Often the answer is "tomorrow." Cut the setup and the answer flips to "yes" more often, because the cost of starting drops to almost nothing. ### It builds consistency, not willpower When starting a session takes 10 seconds instead of 10 minutes, you study on the days you would otherwise skip. [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/), for one example, runs lessons from under a minute to nine, short enough that "I only have 12 minutes" is still a real study session, not an excuse to wait. ## The dead-time this unlocks Zero setup turns dead time into study time: - Between meetings, a 10-minute gap becomes a finished lesson - Lunch break, 25 minutes of coding instead of 10 of setup plus 15 of coding - Waiting rooms, a laptop and a scrim replace scrolling - Early morning, 20 minutes before work becomes real progress None of that works if you first have to remember where you left the project folder. Scrimba autosaves scribbles inside the lesson, so you close the tab mid-scrim and pick up exactly where you stopped. ## What each scrim includes behind the scenes - Pre-configured files: HTML, CSS, JS, and anything else the lesson needs - Installed dependencies: React, libraries and tools ready to run - A mini-browser that renders your HTML/CSS/JS output live - Console output for JavaScript debugging - Scribbles: your edits, saved automatically, that survive closing the browser You never touch any of it directly. You open the lesson and code. ## How does Scrimba's setup compare to YouTube, Udemy and other platforms? | Platform | Setup required | Time to first keystroke | | --- | --- | --- | | Scrimba | None | ~10 seconds | | YouTube tutorial | Install IDE, create project, install deps | 10-15 minutes | | Udemy course | Install IDE, clone repo, install deps | 10-15 minutes | | freeCodeCamp | None (browser-based) | ~30 seconds | | Codecademy | None (browser-based) | ~30 seconds | | The Odin Project | Full local dev environment | 15-30 minutes | freeCodeCamp and Codecademy also run in the browser, but they teach with text, not video. Scrimba is the only one pairing video instruction with a zero-setup editor you can pause and take over. ## Who benefits most from skipping setup Complete beginners. If you have never opened a terminal or configured an IDE, Scrimba lets you skip that and start on the actual programming concept. You can learn the tooling later, once you know why it matters. Busy professionals. Every minute of a 30-minute lunch break counts double when none of it goes to configuration. Our [guide for busy professionals](https://scrimbaguide.tech/docs/for/busy-professionals/) has the realistic weekly hours for fitting a path around full-time work. Neurodivergent learners. Setup tasks lean on executive function: planning, organizing, troubleshooting. For learners with ADHD or similar, skipping that step [removes a real barrier](https://scrimbaguide.tech/blog/scrimba-neurodivergent-learners/), not a minor one. Mobile and lightweight device users. Because everything runs in the browser, a Chromebook, an older laptop or a tablet with a keyboard runs Scrimba exactly like a full workstation. No local IDE, no minimum specs. ## Why it compounds over months The 81.6-hour [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) is 1,493 scrims. A learner who saves 10 minutes per session, 5 sessions a week, reclaims about 21 hours over 6 months, roughly a quarter of that entire path's hours, without changing how hard they study. The saving is not any one session. It is more sessions started, more of each one spent coding instead of configuring, and fewer skipped weeks. ## Related reading - [How Scrimba's Interactive Scrims Work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/), the ghosts, scribbles and full pause-and-code mechanics - [What Makes Scrimba Different](https://scrimbaguide.tech/blog/what-makes-scrimba-different/), the interactive IDE in context - [Building a Coding Habit](https://scrimbaguide.tech/blog/build-coding-habit-scrimba/), why low friction enables consistency - [Scrimba for Busy Professionals](https://scrimbaguide.tech/docs/for/busy-professionals/), realistic weekly hours for limited time - [Best Free Scrimba Courses](https://scrimbaguide.tech/blog/best-free-scrimba-courses/), try the zero-setup format free - [Scrimba vs YouTube](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-youtube/) and [Scrimba vs Codecademy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-codecademy/), how the no-setup format compares to the alternatives - [Is Scrimba free? Pro vs Free](https://scrimbaguide.tech/docs/pricing/pro-vs-free/), what the zero-setup free tier includes ## Start coding in seconds No installs, no configuration, no wasted time. Try Scrimba's free courses in your browser. [Try Scrimba free](https://scrimba.com/?via=u42d4986) ## Frequently asked questions **Q: Do I need to install anything to practice coding on Scrimba?** No. The environment is pre-configured, the files already exist, and the dependencies are installed, so you open the browser, click the next lesson, and start coding. There is no terminal, IDE, or local install to set up first. **Q: How does Scrimba's no-setup practice compare to following a YouTube or Udemy tutorial?** On YouTube or Udemy you typically install an IDE, create the project, and install dependencies before writing any code, which runs roughly 10 to 15 minutes. On Scrimba the time to your first keystroke is about 10 seconds because the scrim environment is already prepared for you. **Q: What does each Scrimba scrim include behind the scenes?** Each scrim ships with pre-configured HTML, CSS, and JS files, installed dependencies such as React and other libraries, a mini-browser that renders output in real time, console output for JavaScript debugging, and scribbles, your saved edits, that survive closing the browser. **Q: Can I use Scrimba on a Chromebook, older laptop, or tablet?** Yes. Because everything runs in the browser, you do not need a powerful development machine. A Chromebook, an older laptop, or a tablet with a keyboard can run Scrimba, with no local IDE installation required. --- # Scrimba for Neurodivergent Learners: Why Hands-On Coding Works Source: https://scrimbaguide.tech/blog/scrimba-neurodivergent-learners/ Scrimba's scrims force you to code every few minutes instead of watching a 45-minute lecture, run in 3 to 15-minute chunks, and let you set your own pace with no cohort to keep up with. That combination removes the three biggest barriers ADHD, autistic, and dyslexic learners hit in a normal coding course, and it does it by how the lesson works, not through any accommodation you have to request. Reviewed inside Scrimba's lessons and course catalog with a Pro account, September 2026. ## Who this is for You learn better in hands-on, short loops, or you need format choices that cut passive-lecture fatigue instead of workarounds bolted onto one. ## Why most coding courses fail neurodivergent learners A typical coding course assumes you can sit through a 45-minute lecture, take notes, then go practice somewhere else. That single design choice creates most of the friction neurodivergent learners run into. ### ADHD-specific challenges - Long videos invite attention drift: ten minutes pass with nothing absorbed - Switching tabs between the tutorial and the editor breaks focus - Watching for 30 minutes before you get to practice does not match how ADHD attention engages - Installing an editor and configuring a project spends executive function before the lesson even starts ### Autism-specific considerations - Uneven pacing in a live lecture or bootcamp session causes sensory overload or under-stimulation - Instructions like "just follow along" skip the structure many autistic learners need - Cohort pressure in a group program adds stress that has nothing to do with the material ### Dyslexia considerations - Text-heavy platforms load large blocks of written instruction onto the same channel you use to read code - Reading code is already hard; dense written explanation on top of it compounds the difficulty ## Is Scrimba good for ADHD? Yes: the format is built around short loops, not long lectures. A scrim pauses itself the moment it hits a challenge, marked by a small purple ghost on the timeline, and hands you the editor. In [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/), Per Borgen's free course, most explanations run two to four minutes before a challenge stops the recording and tells you to "give this one a shot" before you see his solution. That loop repeats well over a hundred times across the course. You are never more than a few minutes from typing, which is closer to how ADHD attention actually works: engagement rises when you are doing, not when you are observing. Every edit you make drops a yellow marker (Scrimba calls it a scribble) on the timeline, saved separately from the instructor's code, so breaking something costs you nothing. Full mechanics are in [how scrims work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/). Lessons across the catalog stay short: [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/)'s scrims mostly run two to four minutes, and [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/)'s run from under a minute to nine. Each one has a natural stopping point, so you get the payoff of finishing something every few minutes instead of waiting 30. Zero setup helps the same problem from a different angle. Opening a lesson and starting to code takes seconds; there is no editor to install, no project to configure, no terminal to open. For an ADHD brain, that is executive function you get to spend on the lesson instead of on getting to the lesson. ## Is Scrimba good for autistic learners? Yes, if ambiguity about what to do next is the problem. Scrimba's career paths remove that ambiguity by sequencing every course in order. The [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) runs about 81.6 hours across 13 modules, and the [6-Month Study Plan](https://scrimbaguide.tech/docs/paths/study-plan/) breaks that into a week-by-week schedule with a fixed milestone at the end of every month, so there is never a question of what comes next. A consistent routine compounds that structure: same time, same number of lessons, same place. Headphones cut environmental noise, since scrim audio is consistent from lesson to lesson. And the solo projects built into every path (a defined spec, no live instructor, no group check-in) suit independent work with clear requirements better than a cohort assignment does. ## Is Scrimba good for dyslexic learners? Yes, because the format gives you three channels instead of one, and none of them requires reading dense paragraphs. You can lean on the audio explanation instead of parsing written instructions, use the mini-browser's visual output to see whether your code works without reading an error message, and pause whenever you need to read code at your own pace. Captions are on by default, and course lessons carry subtitles in ten languages; if a specific line still does not make sense, highlighting it and pressing the built-in EXPLAIN button gets a narrated walkthrough of that exact code, detailed in [how scrims work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/). Increasing your browser's zoom also increases the editor's font size, since Scrimba's editor respects browser zoom settings. ## Accommodations you don't have to ask for Scrimba builds these in rather than making you request them: - Extended time: every lesson is self-paced already - Recorded lectures: every lesson is recorded and repeatable by default - Explaining your needs to an instructor: you learn independently, so there is no one to ask - Coordinating with a disability office: there is nothing to coordinate That removes the social and administrative friction that wears out a lot of neurodivergent learners before the coding even starts. ## Related reading - [How Scrimba's Interactive Scrims Work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/), the pause-and-code mechanics in detail - [Building a Coding Habit](https://scrimbaguide.tech/blog/build-coding-habit-scrimba/), the Tiny Habits approach to staying consistent - [Scrimba for Busy Professionals](https://scrimbaguide.tech/docs/for/busy-professionals/), self-paced strategies that overlap heavily with this one - [6-Month Study Plan](https://scrimbaguide.tech/docs/paths/study-plan/), a structured, predictable schedule - [Best Free Scrimba Courses](https://scrimbaguide.tech/blog/best-free-scrimba-courses/), try the format before committing ## Learn at your own pace, your own way Scrimba's interactive, self-paced format works with your brain, not against it. Try free courses today. [Try Scrimba free](https://scrimba.com/?via=u42d4986) ## Frequently asked questions **Q: Does Scrimba work well for people with ADHD?** Many ADHD learners find it does. Lessons run 3-15 minutes and the format has you coding within seconds of watching, so the tight watch-then-do loop works with short attention spans instead of against them. **Q: Is Scrimba a good fit for dyslexic learners?** It can help. You can lean on the audio explanation and the visual output rather than dense written instructions, pause to read code at your own pace, and increase browser font size since the editor respects zoom. **Q: Do I need to request accommodations to learn this way?** No. The accommodations are built into the platform: everything is self-paced and recorded, so there's no extended-time request, no cohort to keep up with, and no disability office to coordinate with. **Q: Can I try Scrimba before committing?** Yes. Start with the free interactive courses to check whether the hands-on format fits how you learn before upgrading to a paid path. --- # Scrimba React Learning Path: Week-by-Week Study Guide (2026) Source: https://scrimbaguide.tech/blog/scrimba-react-learning-path/ Start with [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) free, about 15 hours with Bob Ziroll. Next, pick one routing course, not both: [Advanced React](https://scrimbaguide.tech/docs/courses/react/advanced-react/)'s Routing module covers the same ground as the standalone [React Router](https://scrimbaguide.tech/docs/courses/react/react-router/) course. Add [React Challenges](https://scrimbaguide.tech/docs/courses/react/react-challenges/) to drill it, then close with interview prep or the React 19 update. Total: roughly 35 hours. Every hour, module and project below comes from our own reviews, each written after going through the course with a Pro account. ## Who this path is for You already write JavaScript, you have not touched React yet, and you want one order to follow instead of guessing at Scrimba's ~10 React courses. If you are still shaky on `map`, `filter`, object destructuring or promises, take [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) first. React's state hooks lean on all four. ## What order should you take Scrimba's React courses in? Four courses, in this order, cover a working React developer's basics: - [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) (free, 15.1 hours) for hooks fundamentals. - [Advanced React](https://scrimbaguide.tech/docs/courses/react/advanced-react/) (Pro, 18.8 hours) for reusability patterns, routing, performance, Supabase persistence, auth, and a TypeScript conversion. - [React Challenges](https://scrimbaguide.tech/docs/courses/react/react-challenges/) (Pro, 9.8 hours) to practice without a walkthrough running. - [React Interview Questions](https://scrimbaguide.tech/docs/courses/react/react-interview-questions/) (Pro, 41 minutes) or [What's New in React 19?](https://scrimbaguide.tech/docs/courses/react/whats-new-in-react-19/) (free, 69 minutes), depending on whether an interview or the latest APIs come first. ### Weeks 1 to 2: Learn React Bob Ziroll's free course runs 15.1 hours across six modules and three real builds: a Chef Claude recipe app that calls Anthropic's Claude API, then two capstones, Tenzies (a dice game) and Assembly: Endgame (a hangman variant where each wrong guess wipes a programming language off the board). Section three, React State, is the long one at 5.2 hours and 58 scrims; that's where props and JSX turn into forms, `useState`, and the Chef Claude fetch call. It's labeled Intermediate and means it: expect the pace to bite there if hooks are new to you. [Start Learn React (Free)](https://scrimba.com/learn-react-c0e?via=u42d4986) ### Weeks 3 to 5: Advanced React, not both routing courses [Advanced React](https://scrimbaguide.tech/docs/courses/react/advanced-react/) runs 18.8 hours across six modules: Reusability (5 hours, building a menu component three different ways until it lands on custom hooks), Routing (6.4 hours, the VanLife camper-van rental app), Performance, Persistence with Supabase, Authentication, and a TypeScript conversion. Its own review page says it straight: the Routing module is "the career-path version of Scrimba's standalone React Router course, so if you already took that, you will be repeating about six hours." Take this course for the full six-module spread and skip the standalone Router course. Take Router on its own only if you want routing in isolation and do not plan to buy the bigger course. ### Week 6: React Challenges Daniel Rose's 9.8-hour course hands you 40 broken or half-built apps, from a synth keyboard to a Game Boy game to a spaceship blaster, each with a written brief and his recorded solution. Only 2.7 of the 9.8 hours are the briefs themselves; the rest is Daniel solving each one, which he tells you to skim if you weren't stuck. The value is the minutes you spend stuck before you press play, not the walkthrough. ### Week 7: interview prep or the React 19 update Pick based on your immediate goal. Cassidy Williams' [React Interview Questions](https://scrimbaguide.tech/docs/courses/react/react-interview-questions/) is 41 minutes: nine scrims of questions with her model answers plus one coding exercise, converting a class-based counter into a function component with `useState`. It drills talking through concepts, not live coding, so pair it with [React Challenges](https://scrimbaguide.tech/docs/courses/react/react-challenges/) if your interviews include a coding round. [What's New in React 19?](https://scrimbaguide.tech/docs/courses/react/whats-new-in-react-19/) is free and 69 minutes: Bob rebuilds one username form four times with the `action` prop, `useActionState`, `useOptimistic`, and `useFormStatus`. Take it if you already write hooks-based React and want the React 19 changes in working code. ## How long does the whole path take? | Course | Hours | Access | Instructor | | --- | --- | --- | --- | | [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) | 15.1 | Free | Bob Ziroll | | [Advanced React](https://scrimbaguide.tech/docs/courses/react/advanced-react/) | 18.8 | Pro | Bob Ziroll (mostly) | | [React Challenges](https://scrimbaguide.tech/docs/courses/react/react-challenges/) | 9.8 | Pro | Daniel Rose | | [React Interview Questions](https://scrimbaguide.tech/docs/courses/react/react-interview-questions/) | 0.7 | Pro | Cassidy Williams | [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/), [Advanced React](https://scrimbaguide.tech/docs/courses/react/advanced-react/), and Challenges alone run about 44 hours. At an hour a day, that's six to seven weeks; at two hours, half that. ## Frequently Asked Questions **Q: Is the free Learn React course enough to get a job?** It gets you hooks, state, and one API-driven build, not enough on its own for most mid-level roles. Routing and a state-management pattern beyond useState, both in Advanced React, are what most job listings expect next. **Q: Do I need both Advanced React and React Router?** No. Advanced React's Routing module teaches React Router 6 in the same VanLife app the standalone course uses, about six hours of overlap. Take the standalone course only if you want routing alone and skip Advanced React entirely. **Q: Does Scrimba teach Redux?** No. Advanced React teaches the Context API and custom hooks instead, which cover most of what Redux solved. The patterns transfer if you need Redux or Zustand later. **Q: What about Next.js?** Scrimba has a separate Learn Next.js course. Finish this React path first; Next.js assumes React fundamentals it does not re-teach. See our [Next.js courses roundup](https://scrimbaguide.tech/blog/best-nextjs-courses/) for how it compares to alternatives. **Q: How much does Scrimba Pro cost?** Check [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) for current rates; plans vary by billing cycle and region. ## Related resources - [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) - [Best Scrimba React Courses](https://scrimbaguide.tech/docs/courses/react/) - [Scrimba Review 2026](https://scrimbaguide.tech/blog/scrimba-review/) ## Ready to start the React path? Learn React is free, no credit card required. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # Scrimba Review 2026: Is It Worth It? Yes, If You Pass This Free Test Source: https://scrimbaguide.tech/blog/scrimba-review/ Direct answer: Yes, for JavaScript, React and AI engineering, if two free sessions keep you typing inside the editor instead of just watching. Scrimba's scrim format puts a live code editor inside every video, so a lesson only works if you pause and edit. It's rated 4.2/5 on Trustpilot, and the Frontend path is [MDN-endorsed](https://scrimbaguide.tech/docs/paths/frontend-developer-path/). Skip it if you need Python-heavy data science, mobile native, or a language outside JS/TS. Run the two-session test below before you pay anything. Reviewed with a Pro account across every course category and all four paths, September 2026. ## The Verdict 4.4/5 For web development and AI engineering in 2026, Scrimba is the strongest interactive platform I've reviewed. The Frontend path carries a real MDN endorsement; the AI catalog is unusually current. Skip it if you need C++, Java, Go, mobile dev, or you mainly study on a phone. ### Pros - Scrim format keeps you coding inside lessons (real engagement, not passive video) - Frontend path is MDN-endorsed and curriculum-aligned - AI catalog is current (agents, RAG, MCP) where most platforms lag - Generous free tier (~24 full courses, including the 15.1-hour Learn React) ### Cons - Narrow language scope (JS/TS, Python, web stack) - Some older courses (Bootstrap 4, Imba, Space Travel) feel dated - Desktop-focused, no real mobile/offline experience - Subscription only, no per-course purchase [Try a scrim in your browser (no signup)](https://scrimba.com/s0v687325e?via=u42d4986) ## Is Scrimba worth it? Run this free test first Yes, if you'll study at least five hours a week for three months on web development, JavaScript, or AI engineering. Not if you haven't tried the free tier first, you need a language outside JS/TS/Python, or you're buying the subscription hoping it will force you to show up. The real comparison isn't "is Scrimba good," it's whether the structure and the Discord are worth more to you than the same hours spent on [freeCodeCamp](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-freecodecamp/), [The Odin Project](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-odin-project/), or plain YouTube. Run this test before you pay anything: - Start the free [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) course (15.1 hours, Bob Ziroll) or [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) (9.4 hours, Per Borgen) if you don't know JS yet. - Block 90 minutes tomorrow and 90 minutes the day after. - Show up both times and pause-and-edit inside the scrim at least three times per session. Two sessions without checking your phone means the format is doing its job and Pro is worth it. Drift after twenty minutes both times and no subscription fixes that. Try a text-based curriculum instead. ## What does a Scrimba lesson actually feel like? Pick any free course, the [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) intro is the clearest example, and click into a lesson. Bob Ziroll talks through a concept with code on screen. Pause anywhere, click into the editor inside the video frame, change the code, run it, and resume: the recording continues from where you paused, with your edits intact. You never toggle between a YouTube tab and VS Code. The teaching pane and the editor are the same surface, so the gap between watching and doing mostly disappears. Working through scrims across several categories, from [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) to the [AI Engineer path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/), feels closer to pair-programming with a recorded mentor than to watching a course. It's not magic. Let a scrim play without touching the editor and you learn as little as you would from any video. But the format nudges you toward typing the next thing, and that nudge is what most "video course" platforms don't have. See [what Scrimba is](https://scrimbaguide.tech/docs/intro/) for the full platform rundown if this is your first time hearing about it. ## What's in the Scrimba catalog? Scrimba publishes around 73+ courses. Here's where the depth sits and where it thins out: - React: the deepest topic on the platform. [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) is free, runs 15.1 hours with Bob Ziroll, and ends in two capstones, Tenzies and Assembly: Endgame, plus a Chef Claude project that calls the Claude API. [Advanced React](https://scrimbaguide.tech/docs/courses/react/advanced-react/), [React Router](https://scrimbaguide.tech/docs/courses/react/react-router/), and [React Challenges](https://scrimbaguide.tech/docs/courses/react/react-challenges/) sit above it. - JavaScript and TypeScript: a full beginner course, advanced JavaScript, regex, interview prep. - AI: around 12 courses covering LLMs, agents, RAG, prompt engineering, the Vercel AI SDK, MCP, the OpenAI API, Claude, and Mistral. This is the category that has grown the most through 2025 and 2026. - CSS and design: Flexbox, Grid, Tailwind, animations, UI design. - Backend: Node, Express, SQL, Supabase, NestJS, cybersecurity. Smaller than the frontend side. - Python: present but not the focus. One free beginner course, rebuilt in August 2026 into a shorter, project-led 4.1 hours, with the longer version it replaced still online. Go, Rust, Java, Kotlin, Swift, C++, mobile native, game dev, and data science beyond a couple of Python pieces are missing. If your goal runs through those languages, Scrimba is the wrong primary platform. See the [full catalog](https://scrimbaguide.tech/docs/courses/) for the current list. The depth is real for JS, React and AI; it thins out fast everywhere else. ## Which Scrimba path should you take? | Path | Hours | Level | Instructor | What you build | | --- | --- | --- | --- | --- | | [Frontend](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) | 81.6 | Beginner | Per Borgen | Hometown Homepage and Learning Journal solo projects, then a portfolio in the 5.1-hour Getting Hired module | | [Fullstack](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) | 108.4 | Beginner | Per Borgen | Frontend builds plus a Node API and a full Node app, closing with a 5.3-hour Launching Your Career module | | [Backend](https://scrimbaguide.tech/docs/paths/backend-developer-path/) | 36.2 | Intermediate | Tom Chant | A live stock-ticker Super Challenge, then routes, SQL, and a deploy | | [AI Engineer](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) | 11.4 | Intermediate | Per Borgen | A hand-built ReAct agent, a RAG search over your own data, a Node app deployed to Render | The [Frontend path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) is the headline product: 13 modules, 1,493 lessons, and the only one carrying Mozilla's endorsement. MDN [reviewed the curriculum](https://developer.mozilla.org/en-US/blog/mdn-scrimba-partnership/) against its own [Curriculum Core](https://developer.mozilla.org/en-US/curriculum/), Scrimba implemented the feedback, and MDN now lists the path as a recommended resource. Our [full path review](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) breaks down all 13 modules with real durations. The [Fullstack path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) is the longest track at 108.4 hours: the Frontend arc plus Node, Express with authentication, SQL, TypeScript, testing and Next.js in one subscription. Take it if you want the complete stack in one sequence. The [AI Engineer path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) reads as a focused specialization, not a bootcamp: nine modules, a weekend clears the lesson runtime, and it assumes you already write JavaScript. The [Backend path](https://scrimbaguide.tech/docs/paths/backend-developer-path/) sits between the two at 36.2 hours. ## Is Scrimba legit? What Trustpilot and Reddit say Scrimba is a real company with a public Trustpilot page and an active paying user base, not a scam or a dropshipped course pack. Its [Trustpilot rating](https://www.trustpilot.com/review/www.scrimba.com) sits at 4.2 out of 5 from 77 reviews as of September 2026. The recurring praise is the format ("I actually code along instead of zoning out") and the [Discord community](https://scrimbaguide.tech/docs/help/community-and-events/). The recurring criticisms hold up: - Older courses occasionally need refreshes (the [Learn Bootstrap](https://scrimbaguide.tech/docs/courses/css/bootstrap/) course, for example, is years behind current CSS practice; it's Pro-gated, with four free preview lessons). - Some advanced project walkthroughs feel thinner than a learner expects after a beginner-friendly intro. - UI glitches inside the editor pane happen, particularly on slower machines. - Subscription renewal complaints (no automatic warning before renewal). Check your renewal date, and read our [refund policy](https://scrimbaguide.tech/docs/pricing/refund-policy/) before you subscribe so you know the cancellation window. On [Reddit's r/learnprogramming](https://www.reddit.com/r/learnprogramming/) and r/webdev, the recurring take is that Scrimba is strong for React and the early phases of becoming a frontend developer, and that learners often supplement with [The Odin Project](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-odin-project/), [freeCodeCamp](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-freecodecamp/), or YouTube for specific topics. That's a healthy study pattern, not a red flag. ## Is the Scrimba certificate worth it? Not for hiring on its own. Employers hire on your portfolio and your interview, not a certificate line. What the [Frontend path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) actually gives you to show off is the Hometown Homepage and Learning Journal solo projects plus the 5.1-hour Getting Hired module on GitHub, LinkedIn, and interview drills. Our [full certificate guide](https://scrimbaguide.tech/blog/complete-guide-scrimba-certificates/) covers what the certificate looks like, where you can add it, and why it still helps as a resume signal even though it isn't the reason to enroll. ## What does Scrimba Pro cost? Scrimba runs one subscription, billed monthly or annually. Annual costs less per month and pays off past three months of study. A verified [student discount](https://scrimbaguide.tech/docs/pricing/student-discount/) exists, the GitHub Student Developer Pack adds a free month, and Scrimba applies regional purchasing-power pricing automatically in lower-income countries (a VPN to fake your region gets you banned, not a discount). Regional pricing and promotions shift, so we never quote a number here. Here's the realistic field of options instead: | Option | What you get | What you don't | | --- | --- | --- | | YouTube + docs | Infinite free content | Zero structure, you design your own curriculum | | [freeCodeCamp](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-freecodecamp/) + [The Odin Project](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-odin-project/) | Real structured free curriculum | Text-heavy, no instructor voice | | Scrimba Pro | Paths, scrims, Discord, MDN-aligned Frontend path | Narrow language scope, no live number here, check our [pricing page](https://scrimbaguide.tech/docs/pricing/) | | [Coding bootcamp](https://scrimbaguide.tech/docs/pricing/scrimba-vs-bootcamps/) | Cohort, mentors, deadlines, job services | An industry average around $14,000 in the US, per [Course Report](https://www.coursereport.com/coding-bootcamp-ultimate-guide) | Even without a Scrimba number, the bootcamp math is the easy comparison: a subscription that costs a fraction of that $14,000 average buys you years of Pro before you'd spend what a single bootcamp costs, which is part of why [so many coding bootcamps have shut down](https://scrimbaguide.tech/blog/coding-bootcamps-closing-2026/) since 2023. The harder call is Scrimba Pro against free curriculum, where the honest answer is that structure and the Discord are what you're paying for, not content you can't get elsewhere. Full breakdown, including the student discount and refund window, on our [pricing page](https://scrimbaguide.tech/docs/pricing/). ## Who should pay for Pro, and who shouldn't Pros, ranked by what actually sold me: - Scrim format. The single best argument for paying. - MDN-aligned Frontend path. Real partnership, not a marketing badge. - AI catalog is genuinely current. Most platforms still ship 2023-era prompt-engineering courses. - Free tier is unusually generous. About 24 full courses, including the 15.1-hour [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/). - Discord is active. Pro subscribers get real human help. Cons, in the same order of weight: - Narrow scope. If your stack lives outside JS/TS/Python/web, look elsewhere. - Some older courses are dated and shouldn't be your starting point: the [Bootstrap](https://scrimbaguide.tech/docs/courses/css/bootstrap/) course (Pro-gated) and the free Imba and Space Travel courses. - Desktop-only experience. No real mobile app, no offline. - Backend and AI paths are short relative to Frontend. - No per-course purchase. You're paying for the bundle or nothing. You'll get your money's worth if: - You're aiming at frontend, fullstack, or AI engineering roles. - You'll actually study at least 5 hours a week for 3+ months. - You learn by typing, not by passively watching. - You'll use the Discord rather than treating it as wallpaper. You'll waste money if: - You haven't tried a free course first. - You're between languages and not sure yet whether you want JS or something else. - You like learning on a phone during commutes. - You're paying as motivation, hoping the subscription will force you to study. If you do buy, get the most out of it: - Pick annual billing. Monthly costs more per month and tempts you to cancel before you've used it. - Commit to one path, not three. Frontend, fullstack, backend, or AI Engineer. - Use the Discord. It's the part you can't get from free curricula. - Check the [student discount](https://scrimbaguide.tech/docs/pricing/student-discount/): an academic email or the GitHub Student Pack both work. - Set a renewal calendar reminder. Trustpilot's recurring complaint is a silent renewal, not a scam. ## How Scrimba compares - [Scrimba vs Codecademy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-codecademy/): scrims vs text drills, similar price tier. - [Scrimba vs Udemy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-udemy/): curated vs marketplace. - [Scrimba vs freeCodeCamp](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-freecodecamp/): paid interactive vs free text-heavy. - [Scrimba vs Frontend Masters](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-frontendmasters/): beginner-friendly vs senior-engineer workshops. - [Scrimba vs The Odin Project](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-odin-project/): structured paid path vs open-source curriculum. - [Scrimba vs coding bootcamps](https://scrimbaguide.tech/docs/pricing/scrimba-vs-bootcamps/): roughly two orders of magnitude cheaper. - [Scrimba vs YouTube coding tutorials](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-youtube/): scrim format vs free video, if you're still deciding between paid structure and DIY. Since mid-2026 Scrimba also ships [Scrimba Explain](https://scrimbaguide.tech/blog/scrimba-explain-review/), which turns a question, an article or your own codebase into a narrated video explainer. It's a small part of the Pro math (free accounts get 10 for life, Pro gets 100 a month), not a reason to subscribe on its own. On "Scrimba got me a job" claims: you'll see these stories in Scrimba's own marketing, and some are real. The honest version is that the Frontend path teaches job-ready skills, but getting hired still needs a working portfolio, a real LinkedIn presence, and dozens to hundreds of applications in a market that's cooled since 2021. The platform covers the curriculum half. The applications half is yours; see our [job market reality](https://scrimbaguide.tech/blog/junior-developer-job-market-2026/) and [how to get hired](https://scrimbaguide.tech/blog/how-to-get-first-developer-job-2026/) guides for the unvarnished version. ## Is Scrimba worth it? The verdict 4.4/5. Scrimba is the strongest interactive platform I've reviewed for the JS/TS/AI/web slice of programming. The [Frontend path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) is the strongest single product on the platform, and the MDN endorsement is real, not a marketing badge. The limits are real too: narrow scope, no mobile experience, a handful of dated free courses. Try the free tier first. If you do two sessions of a free course and find yourself opening the editor unprompted, Pro earns its keep. If you don't, no subscription will fix that. Start with the free [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) course if you already know JavaScript, or the [Frontend path](https://scrimba.com/frontend-path-c0j?via=u42d4986) if you're starting from zero. ## Ready to start with Scrimba? Try 24 courses free, or go Pro for full access to all 73+ courses and 4 career paths. Use our partner link to get 20% off the Pro plan. [Claim 20% off Scrimba Pro](https://scrimba.com/our-pricing?via=u42d4986) 7-day refund, cancel anytime. ## Frequently asked questions **Q: Is Scrimba worth it in 2026?** For web development and AI, yes, if you'll study consistently. Try at least one free course first. Pro pays back when you'll use the structured paths and Discord for several months. **Q: Is Scrimba better than Udemy?** For the topics it covers (JS, React, AI, CSS), the interactive format makes Scrimba stronger for retention. Udemy wins on breadth and per-course purchases. **Q: Can Scrimba get me a developer job?** The Frontend path teaches job-ready skills and is MDN-endorsed. Getting hired still requires a real portfolio, applications, and a competitive market. Plan months, not weeks. **Q: What's the catch with Scrimba?** Narrow language scope, desktop-only experience, a handful of older free courses that are dated, and subscription renewal that doesn't warn you. Read the cons section before paying. **Q: Is Scrimba legit?** Yes. It's a real company with a public 4.2/5 Trustpilot rating from 77 reviews, an MDN-endorsed Frontend path, and an active Discord community. The recurring complaints are dated free courses and no renewal warning, not a scam pattern. **Q: Is Scrimba cheaper than a bootcamp?** By roughly one to two orders of magnitude. US coding bootcamps average around $14,000, per Course Report's industry data. A Scrimba subscription costs a fraction of that, though a bootcamp also bundles cohort deadlines and career services you'd have to provide yourself with Scrimba. **Q: Should I pay before finishing a free course?** No. Start Learn React or Learn JavaScript first. If you don't show up for two sessions of a free course, paying for Pro won't fix that; the format has to hook you before the subscription is worth anything. ## Sources - [MDN partners with Scrimba](https://developer.mozilla.org/en-US/blog/mdn-scrimba-partnership/) - Mozilla announcement of the curriculum alignment. - [MDN Curriculum](https://developer.mozilla.org/en-US/curriculum/) - the curriculum Scrimba's Frontend path aligns with. - [Scrimba on Trustpilot](https://www.trustpilot.com/review/www.scrimba.com) - aggregated learner reviews. - [r/learnprogramming](https://www.reddit.com/r/learnprogramming/) - the community thread of record for these conversations. - [Course Report's bootcamp cost data](https://www.coursereport.com/coding-bootcamp-ultimate-guide) - the ~$14,000 US bootcamp average, verified 2026-09-28. - [Our Scrimba pricing breakdown](https://scrimbaguide.tech/docs/pricing/) - what free and Pro include, and where to check the live rate. --- # Scrimba Roadmap 2026: What's Coming Next Source: https://scrimbaguide.tech/blog/scrimba-roadmap-whats-coming/ Learn DevOps and Advanced TypeScript are the two confirmed courses still on Scrimba's 2026 roadmap. Next.js Section 3, Unit Testing, and Build AI Agents already shipped, and [Advanced React](https://scrimbaguide.tech/docs/courses/react/advanced-react/) quietly doubled from three modules to six. The platform is moving fast from a frontend school to a full-stack and AI one. Reviewed inside Scrimba's courses and paths with a Pro account, updated September 2026. ## What is Scrimba shipping next? Two courses are officially in production, per Scrimba's own roadmap page: Learn DevOps. Not live yet. Scrimba has said it will cover CI/CD pipelines and Docker, likely with AWS or DigitalOcean basics. If you cannot wait, the [Backend Developer Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/) already has a dedicated DevOps module: 4 hours and 42 lessons inside Tom Chant's 36.2-hour path. Advanced TypeScript. Also not live. Expect generics and utility types (`Pick`, `Omit`, `Partial`) beyond what the Fullstack and Backend paths already teach. Neither course exists in the catalog yet. Treat "coming soon" as Scrimba's own label, not a date: their release windows have historically run one to three months once a course enters production. ## What has Scrimba already shipped in 2026? If you have not checked the catalog in a while, here is what changed: - [Advanced React](https://scrimbaguide.tech/docs/courses/react/advanced-react/): grew from three modules to six, adding Persistence, Authentication, and TypeScript in React. Bob Ziroll's course went from about 13 hours to 18.8 across 240 lessons, the biggest single content addition on the platform this year. - [Learn Next.js](https://scrimbaguide.tech/docs/courses/javascript/nextjs/): Section 3, "Making Data Flow," shipped at 3.9 hours and 64 lessons, the largest of its three modules. The course now runs 8.5 hours and has you build PrintForge, a 3D-model catalog, first with static pages and then a SQLite database with search and pagination. - [Learn Python](https://scrimbaguide.tech/docs/courses/python/learn-python/): rebuilt in August 2026 by Treasure Porth. The new version runs 4.1 hours across three modules and three projects, an expense-splitting app, a word-scramble game, and a karaoke queue manager. It is shorter than the course it replaced and stops before dictionaries, file handling, and classes. - [Learn Cybersecurity](https://scrimbaguide.tech/docs/courses/javascript/cybersecurity/): Rachel Johnson and Jonathan Hill's 5-hour Pro course has you plant a SQL injection payload and watch the runner terminal print "Disaster dropping users table," then build Express rate limiters. - [Build AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/): Bob Ziroll's course on autonomous agents that take actions, use tools, and loop until a goal is done. - [Unit Testing](https://scrimbaguide.tech/docs/courses/javascript/unit-testing/): a focused course on Vitest/Jest-style patterns, written as you code. - [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/): Arsala Khan's 2.5-hour crash course on LLM-powered web apps, updated for 2026's models. - [The Backend Developer Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/): Tom Chant's 36.2-hour path across 12 modules, Node, Express, SQL, TypeScript, security, and deployment. - [Learn Context Engineering](https://scrimbaguide.tech/docs/courses/ai/context-engineering/): a 60-minute crash course on optimizing what you feed an LLM's context window. - [Intro to Model Context Protocol (MCP)](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/): Maham Codes' 37-minute course on connecting AI to your local files and data. ## Is Scrimba becoming a full-stack and AI platform? Yes. Three moves back it up. Backend is no longer an afterthought: the [Backend Developer Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/), [Learn Cybersecurity](https://scrimbaguide.tech/docs/courses/javascript/cybersecurity/), and the upcoming Learn DevOps cover the entire stack, not just the browser. AI is not a novelty add-on either; [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/), [Learn Context Engineering](https://scrimbaguide.tech/docs/courses/ai/context-engineering/), and [Intro to MCP](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/) treat it as its own engineering discipline, with three separate short courses stacking depth rather than one overview. And the newer releases skew toward job-readiness: Unit Testing and the coming Advanced TypeScript are about writing production code, not just finishing a project. ## Frequently Asked Questions **Q: Do new courses cost extra?** No. If you have an active Scrimba Pro subscription, all new Pro courses are included automatically. You don't need to pay for them separately. **Q: When exactly will these courses be released?** Scrimba rarely gives hard release dates. 'Coming Soon' usually means within 1-3 months, but it can vary depending on production complexity. **Q: Will there be a Python path?** There is no official Python Career Path on the roadmap yet, and Scrimba remains heavily focused on the JavaScript/TypeScript ecosystem. The one signal worth noting: in August 2026 Scrimba rebuilt its free Learn Python course from scratch, handing it to Treasure Porth (a Frontend and Fullstack path contributor) and restructuring it into modules with three projects. That is path-team treatment applied to a standalone course. It is also shorter than the version it replaced, so read it as maintenance rather than the start of a Python track. ## Related pages - [All courses](https://scrimbaguide.tech/docs/courses/) - [Scrimba pricing](https://scrimbaguide.tech/docs/pricing/) - [Review: Scrimba Review 2026](https://scrimbaguide.tech/blog/scrimba-review/) ## See what's new for yourself Every course and path on this list, from Next.js to the Backend Developer Path, starts free to try. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # Scrimba Success Stories: What Real Reviews Actually Say in 2026 Source: https://scrimbaguide.tech/blog/scrimba-success-stories/ Scrimba's Trustpilot page sits at about 4.3 out of 5, and the reviews that back it up follow one pattern: people who finish a free course first and pay for Pro second are the ones who credit Scrimba with a job. Nobody gets hired in a week. The realistic timeline is months of study plus dozens of applications. Sourced from [Trustpilot's Scrimba page](https://www.trustpilot.com/review/www.scrimba.com) and recurring [r/learnprogramming](https://www.reddit.com/r/learnprogramming/) threads, read in full in September 2026, plus our own course reviews for the specifics reviewers gloss over. ## Who this is for You want the patterns behind public reviews, not curated testimonials, before you spend real hours. ## Do Scrimba success stories hold up? Read enough of them and five patterns repeat across Trustpilot and Reddit. None describe getting hired in a week; all of them describe months. ### Pattern 1: free tier first, Pro second The most credible positive reviews start the same way: someone finishes [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) or [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) for free, then pays for Pro. Bob Ziroll's free course runs about 15 hours and ends in two capstones, Tenzies and Assembly: Endgame; Per Borgen's free course runs about 9.4 hours across eight modules and ends in a Chrome extension and a Firebase-backed mobile app. Reviewers finish one of those, then upgrade. Rarely the reverse. If you haven't finished a free course, Pro buys motivation, and motivation isn't for sale. Start with the [free course list](https://scrimbaguide.tech/blog/best-free-scrimba-courses/). ### Pattern 2: the tutorial-hell escape Reviewers who abandoned Udemy, YouTube, or Codecademy before Scrimba credit the in-browser editor, not the content. [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/)'s own instructions show why: every challenge stops the recording and says "go ahead and give this one a shot, and then of course return back to the screencast when you want to see my solution," a loop that repeats well over a hundred times in the course. Passive video never forces that. Editing the instructor's code does. If that's the pattern you recognize in yourself, the [tutorial hell guide](https://scrimbaguide.tech/docs/how-it-works/tutorial-hell/) covers the loop in detail. ### Pattern 3: career changers who layered Scrimba with other resources "Scrimba got me a frontend internship" reviews almost always mention a second resource: [The Odin Project](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-odin-project/) for a free, real-environment Foundations track, or [freeCodeCamp](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-freecodecamp/) for its 11 certifications and blank-editor projects, plus months of applications. Scrimba is rarely the only input; the credible reviews say so themselves. Scrimba teaches the curriculum half. Applications and a portfolio are the other half, covered in [how to get hired with Scrimba](https://scrimbaguide.tech/blog/how-to-get-first-developer-job-2026/). Want to test the loop before reading more stories? [Learn JavaScript](https://scrimba.com/learn-javascript-c0v?via=u42d4986) is free and needs no signup to start. Click pause, edit the code, run it. That's the entire mechanism the review patterns above describe. ### Pattern 4: working developers upskilling A share of the positive [Trustpilot reviews](https://www.trustpilot.com/review/www.scrimba.com) come from people already employed as developers, using Scrimba to pick up React 19, TypeScript, or AI engineering fast. The [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) is the clearest case: 11.4 hours across nine modules, and you build a ReAct agent by hand, a RAG search over your own data, and deploy a Node app to Render. New modules (MCP, Context Engineering) shipped recently, so working developers renew for the additions rather than rebuying the basics. ### Pattern 5: the negative reviews These recur too, and they're worth surfacing: silent subscription renewals (set a calendar reminder), older free courses showing their age (Bootstrap 4, Imba, Space Travel), and editor glitches on slower machines. Read the full [Scrimba review](https://scrimbaguide.tech/blog/scrimba-review/) for the unvarnished version. ## What the patterns add up to The people who get the most out of Scrimba share three habits: they finish the free tier before paying, they use the Discord instead of ignoring it, and they layer Scrimba with The Odin Project or freeCodeCamp for breadth, then apply to dozens of jobs instead of waiting for the certificate to do the work. None of that is unique to Scrimba; it's how self-paced learning works everywhere. The format is what's unique. The interactive scrim is what review after review credits for finishing a course for the first time. If you've abandoned three platforms already, that's the variable worth testing. ## How to evaluate the stories yourself - Read the negative reviews too. [Trustpilot's full Scrimba page](https://www.trustpilot.com/review/www.scrimba.com) sorts by lowest rating; read at least ten before paying. - Search Reddit for yourself. "Scrimba review" on [r/learnprogramming](https://www.reddit.com/r/learnprogramming/) and r/webdev turns up long-form threads with both sides. - Try a free course. This is the only review that matters for your situation specifically. - Talk to the Discord. Pro subscribers get a community where you can ask current learners directly. If the free-tier test holds up for you, read [Scrimba Review 2026](https://scrimbaguide.tech/blog/scrimba-review/) next for the cost-benefit breakdown. ## Sources - [Scrimba on Trustpilot](https://www.trustpilot.com/review/www.scrimba.com), aggregated long-form learner reviews. - [r/learnprogramming](https://www.reddit.com/r/learnprogramming/), recurring discussion threads about Scrimba. - [MDN partners with Scrimba](https://developer.mozilla.org/en-US/blog/mdn-scrimba-partnership/), the credibility signal most reviews mention. ## Test the format before trusting any review The free tier covers Learn React and Learn JavaScript end-to-end. No card required. [Try Scrimba free](https://scrimba.com/?via=u42d4986) ## Frequently asked questions **Q: Are Scrimba success stories real?** The public reviews on Trustpilot and Reddit are real and verifiable. Marketing testimonials curated on company pages should always be read with the same skepticism you'd apply to any vendor. Read the negative reviews too. **Q: How long does it take to get hired through Scrimba?** Months, not weeks. The realistic timeline across credible reviews is several months of consistent study plus dozens to hundreds of applications. Anyone promising faster has something to sell. **Q: Can I start with free resources before paying?** Yes, and you should. The most positive long-form reviews start with the free tier (Learn React or Learn JavaScript), then upgrade once the format has proven it works for them personally. **Q: What's the most common pattern in successful Scrimba stories?** Layering. Scrimba for the structured interactive curriculum, The Odin Project or freeCodeCamp for breadth, real portfolio projects, and consistent applications over months. --- # Scrimba vs ChatGPT: Is a Paid Coding Course Worth It in 2026? Source: https://scrimbaguide.tech/blog/scrimba-vs-chatgpt-learn-to-code/ ChatGPT teaches for free; Scrimba makes you write the code yourself. Pay for Scrimba if you have stalled on courses before or cannot yet spot a wrong-but-plausible AI answer. Skip it if you already code and just need an instant explainer. Most beginners need the forced typing more than they think. I reviewed Scrimba's [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) and its courses with a Pro account, and checked every study and stat below against its own source. ## Why pay for a course when ChatGPT is free? You pay for what a chatbot cannot give you: a fixed order to learn in, and enforcement that makes you write the code instead of reading someone else's. ChatGPT explains better than most human tutors. It teaches worse, because teaching is mostly about what it makes you do, not what it tells you. Passive video tutorials are losing viewers as learners build alongside an AI in the next tab instead, part of why "tutorial hell is dead" pieces spread early in 2026. Everyone now has a free, patient tutor open around the clock, and a chatbot replaces a chunk of what a beginner used to pay for. The rest of this post is about which chunk it replaces, and which chunk it does not. ## What can ChatGPT actually teach you for free? Free AI answers your exact question, at any hour, in your own words, tuned to your level. It does not give you a reason to write anything yourself, a sequence to follow, or a check that you understood the answer instead of nodding at it. Those strengths are real. Stuck on why your fetch returns undefined? Paste it, get an answer in thirty seconds. Never heard of a debounce? Ask, and you get a clear explanation with an analogy. No course matches that speed, though Scrimba built its own version: [Scrimba Explain](https://scrimbaguide.tech/blog/scrimba-explain-review/) answers a question, or the line you highlighted in a lesson, as a short narrated video with a quiz, 10 free for life and 100 a month on Pro. The gap shows up later, when AI hands you code that looks right, runs, and is subtly wrong. That is the failure mode that hurts, not the bug that crashes the page. The Stack Overflow 2025 Developer Survey, released July 2025, found the single biggest developer frustration, named by 66% of respondents, is AI output that is "almost right, but not quite." A senior engineer spots that in a glance. A beginner cannot, because spotting it is the exact skill they are still building. Adoption keeps climbing (84% of developers use or plan to use these tools) while trust in the output keeps falling. ## What happens to your skills when AI writes the code for you Comprehension drops when AI writes the code, and Anthropic measured it. In a randomized controlled trial published January 29, 2026, 52 mostly-junior engineers split into an AI-assisted group and a group that coded by hand. The AI-assisted group averaged 50% on a comprehension quiz afterward versus 67% for the manual coders, roughly two letter grades (Cohen's d of 0.738, p-value 0.01), with the widest gap on debugging questions. The penalty was not universal. Developers who used AI strategically, asking it to explain concepts and walk through errors rather than generate the code, retained far more. AI is not the problem; letting it ghostwrite is. That distinction decides everything else in this post, and I cover the skill it points to in [how to get better at reading code in 2026](https://scrimbaguide.tech/blog/how-to-get-better-at-reading-code-2026/). ## What does a Scrimba subscription actually buy you? Structure, sequence, and forced typing. Scrimba's lessons are interactive "scrims": the video pauses and you edit the instructor's own code in the browser, then run it. You cannot watch your way through, and that is the Anthropic study's manual group turned into a product. The sequence is the other half. A chatbot answers whatever you ask, so your curriculum is only as good as the questions a beginner already knows to ask, and beginners do not know what they do not know. A path closes the gaps you would not have thought to fill. Scrimba's [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) packs 1,493 scrims into 13 modules; the React basics module alone runs 15.3 hours over 157 lessons with Bob Ziroll walking you from components to state before the path moves on to hooks and routing. There is a Discord community for the 11pm question nobody at home can answer. You can start Scrimba's JavaScript and frontend courses free before paying anything, so try the forced-typing format first and see if it fits how your brain works. If it does, Pro is a monthly subscription (current [Scrimba pricing](https://scrimbaguide.tech/docs/pricing/)). For the wider field of hands-on platforms, [the best interactive coding platforms for 2026](https://scrimbaguide.tech/blog/best-interactive-coding-platforms-2026/) compares several. ## Where does ChatGPT still beat a paid course? On breadth, speed, and price, no course competes. ChatGPT explains a concept your course never covered, debugs the specific error in front of you, and answers at 2am for free. A pre-recorded course does none of that. If you are an experienced developer picking up a new language, a chatbot plus the official docs may be all you need. You already have the judgment to spot the almost-right answer, so the main risk of AI is off the table for you. Same if your question is niche: some obscure webpack config, a regex edge case, a library with three GitHub stars. No course has a lesson on that; AI does, sort of, and it is instant. A course is a fixed body of content that ages, while a chatbot pulls from far more and does not care that your stack is unusual. For "I just need to understand this one thing right now," free AI wins outright. ## Who should skip Scrimba and just use AI? Skip the subscription if you are a disciplined self-starter, already know one language, and will enforce your own practice. Free AI plus a free interactive platform gets you there. Pay for structure if you have started and stalled before, or if you cannot yet tell good code from almost-right code: those are the exact two problems a chatbot makes worse and a sequenced, hands-on course makes better. Scrimba falls short in specific ways. Its Trustpilot rating sits in the mid-4s out of 5. Reviewers praise the scrim format and the Discord community, and just as often flag two things: some older courses need refreshing, and no warning email arrives before the subscription renews. Set a calendar reminder for the renewal date so you decide on purpose. No course fixes the underlying trap if you let AI ghostwrite your homework alongside it. The format pushes you to type; it cannot stop you from pasting. ## How do you combine Scrimba and AI without losing the skill? Use the course as the spine and AI as the tutor, never the ghostwriter. Let Scrimba set the sequence and force the typing. Let ChatGPT explain what confused you, review code you already wrote, and quiz you on it. Inside a scrim, the EXPLAIN button does that first job without leaving the lesson, since Scrimba Explain builds the answer from the code in front of you. Mimo's teardown of AI-assisted learning lands on the same split: learners who write first and ask AI to explain keep the skill, while those who let it write the code cannot debug their way out later. Anthropic's data backs the same habit, since the strategic users in that trial retained far more. In practice it comes down to small defaults. When the AI shows you code, retype it instead of pasting, so your memory stays involved. Never keep a line you could not rewrite from scratch tomorrow. Ask "why is mine wrong" more than "write me a working one." I laid out the full method, with prompt examples and a 30-day plan, in [how to learn coding without depending on AI](https://scrimbaguide.tech/blog/how-to-learn-coding-without-depending-on-ai/). If you are not sure whether a structured path is even the right move for your goals, the [path finder](https://scrimbaguide.tech/tools/which-scrimba-path/) takes about a minute and is free. ## References - [Anthropic: how AI assistance impacts the formation of coding skills](https://www.anthropic.com/news/AI-assistance-coding-skills) - the January 2026 randomized trial on comprehension (50% vs 67%) and strategic use. - [Stack Overflow 2025 Developer Survey: AI section](https://survey.stackoverflow.co/2025/ai/) - 84% adoption, falling trust, and the 66% "almost right, but not quite" frustration. - [Should you use AI to learn to code? (Mimo)](https://mimo.org/blog/should-you-use-ai-to-learn-to-code) - the mentor-versus-ghostwriter framing. - [Scrimba reviews on Trustpilot](https://www.trustpilot.com/review/www.scrimba.com) - the mid-4s rating, plus the recurring praise and complaints. **Q: Is Scrimba worth paying for if I already use ChatGPT every day?** It depends on your discipline. If you have started courses and stalled before, or you cannot yet tell good code from almost-right code, paying for a sequenced, hands-on course fixes the two things a chatbot makes worse. If you are a disciplined self-starter who already knows a language, free AI plus a free interactive platform can be enough. **Q: Can you really learn to code with just ChatGPT for free in 2026?** You can, but the risk is real. Anthropic's January 2026 trial found AI-assisted learners scored about two letter grades lower on a comprehension quiz than people who coded by hand. It works only if you write the code yourself and use AI to explain concepts, not to generate finished answers you paste and forget. **Q: Does ChatGPT teach coding better than a paid course?** ChatGPT explains better; a course teaches better. The chatbot answers your exact question instantly and for free, which no recording can match. A structured course makes you write and run code in a deliberate order, which is what builds skill. The strongest results come from using both, in the right roles. **Q: Why does AI-generated code hurt beginners the most?** Because the top developer frustration in the Stack Overflow 2025 survey, named by 66% of respondents, is AI output that is almost right but not quite. A senior engineer catches that at a glance. A beginner is the person least able to catch it, since spotting it is the exact skill they are still trying to build. **Q: How should I use AI while taking a Scrimba course?** Treat AI as a tutor, not a ghostwriter. Write every line yourself inside the scrim, then ask the AI to explain errors, review your code, or quiz you on what you just built. Scrimba's own Explain button in the lesson header does the explaining as a narrated video built from that scrim. When it shows you code, retype it instead of pasting, and never keep a line you could not rewrite from scratch tomorrow. ## Pay for the part ChatGPT skips Scrimba makes you write and run the code yourself, so the skill sticks instead of scrolling past. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # Scrimba vs Coding Bootcamps: Full Cost Analysis (2026) Source: https://scrimbaguide.tech/blog/scrimba-vs-coding-bootcamps-cost/ Bootcamps cost $10k–$20k in tuition alone; total cost with lost income can exceed $30k. Scrimba Pro costs a subscription (check current pricing) with no lost income since you study part-time. Scrimba is better if you can't afford tuition or quit your job; bootcamps are better if you need maximum structure, employer networks, or a job guarantee. ## Who This Is For Career changers weighing Scrimba vs bootcamps, anyone who must keep working while learning, or learners evaluating total cost including opportunity cost. ## How Much Does a Coding Bootcamp Cost in 2026? Average coding bootcamp costs in 2026: | Cost Category | Range | | --- | --- | | Tuition | $10,000 - $20,000 | | Living expenses (if full-time, 3-6 months) | $6,000 - $15,000 | | Lost income (if you quit your job) | $15,000 - $40,000 | | Equipment and materials | $500 - $2,000 | | Total real cost | $31,500 - $77,000 | The tuition alone averages $13,500, but the true cost includes opportunity cost, the income you forgo while studying full-time. Some bootcamps offer Income Share Agreements (ISAs) where you pay a percentage of your salary after landing a job. These can cost more in total than upfront tuition. That tuition risk is real in a different way too: [several coding bootcamps have closed](https://scrimbaguide.tech/blog/coding-bootcamps-closing-2026/) since 2023, leaving mid-program students stranded. ## How Much Does Scrimba Cost? Is It Free? Scrimba isn't fully free. About two dozen courses, [enough to learn the fundamentals](https://scrimbaguide.tech/blog/best-free-scrimba-courses/), cost nothing forever. The paths that make this comparison meaningful, Fullstack, Frontend, Backend and AI Engineer, sit behind Pro. | Cost Category | Amount | | --- | --- | | Scrimba Pro subscription (6-8 months) | Check current pricing | | Equipment (you probably already have a laptop) | $0 | | Lost income | $0 (study part-time while working) | | Total real cost | Scrimba subscription only | The key financial advantage: you keep your job. Scrimba's self-paced format means you study 10-15 hours per week alongside your current employment. Students can trim the subscription cost further with the [student discount](https://scrimbaguide.tech/docs/pricing/student-discount/). ## What You Get: Curriculum Comparison | Feature | Scrimba Pro | Typical Bootcamp | | --- | --- | --- | | Content hours | 108.4 hrs ([Fullstack Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/)) | 400-600 hrs | | Learning format | Interactive video (self-paced) | Live instruction + projects | | Career support | Career module + Discord | Career coaching, resume reviews | | Duration | 4-8 months (part-time) | 12-24 weeks (full-time) | | Accountability | Self-motivated | Structured schedule with cohort | | Job guarantee | No | Some offer guarantees | | Networking | Discord community | Cohort-based networking | | Technologies | JS, React, Node, AI, CSS | Varies by bootcamp | Seven instructors teach the Fullstack path's 20 modules, and its last one, Launching Your Career, runs 5.3 hours on portfolio, resume, GitHub, LinkedIn and interview drills, the same ground a bootcamp's career-services team charges extra for. The path also nests a 56-minute Testing module and a 24-scrim authentication build inside Express.js, so "108 hours" is dense, not padded. ## The Accountability Factor This is where bootcamps have a genuine advantage. When you're paying $15,000 and attending class 40 hours a week with a cohort, you're highly motivated to finish. Scrimba requires self-discipline. Scrimba's answer to this: - The [Discord community](https://discord.gg/scrimba) provides accountability partners - Career paths have clear milestones and certificates - The interactive format reduces the temptation to passively watch But if you know you struggle with self-motivation, a bootcamp's structure may be worth the premium. ## Job Outcomes Bootcamps report 70-90% job placement rates within 6 months. Take these numbers with skepticism: they often exclude dropouts and count part-time or unrelated positions as placements. Scrimba doesn't publish placement rates, but its Discord is full of success stories from career changers who landed web development roles after finishing the career paths. See [what Fullstack path learners actually say](https://scrimbaguide.tech/blog/scrimba-fullstack-path-reviews/) for the specifics. Neither platform controls the number that matters most: what the job pays once you land it. ZipRecruiter puts average U.S. back end developer pay around $120k, and the BLS lists national medians above $80k for Software Developers and Web Developers ([BLS Software Developers](https://www.bls.gov/ooh/computer-and-information-technology/software-developers.htm), [BLS Web Developers](https://www.bls.gov/ooh/computer-and-information-technology/web-developers.htm)). That salary is the same whether you got there through a $15,000 bootcamp or a Scrimba subscription. Your portfolio, networking and interview skills decide the outcome, not the platform. ## Choose Scrimba vs Bootcamp Choose Scrimba if: - You can't afford $15,000+ in tuition (or don't want ISA debt) - You can't quit your job to study full-time - You're disciplined enough to study independently - You want web development or AI specifically (Scrimba's focus) - You learn well from interactive video and hands-on practice Choose a bootcamp if: - You need external structure and accountability to finish - You can invest the time and money for a full-time program - You value in-person networking with a cohort - You want career services (resume reviews, mock interviews, job placement) - You learn better in a classroom setting with live instructors ## The Hybrid Approach Many successful developers use both: - Start with Scrimba, build fundamentals and a small portfolio - Evaluate if you need more, if you're landing interviews, keep going - Consider a bootcamp only if you need the structure, networking, or career services that self-study can't provide This approach lets you test your commitment before making a $15,000+ investment. ## Related Pages - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) | [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) - [How to Get Hired with Scrimba](https://scrimbaguide.tech/blog/how-to-get-first-developer-job-2026/) - [Scrimba Certificates](https://scrimbaguide.tech/docs/how-it-works/accreditation/) | [Learning Speed Guide](https://scrimbaguide.tech/docs/how-it-works/learning-speed/) - [Best Free Scrimba Courses](https://scrimbaguide.tech/blog/best-free-scrimba-courses/) | [Scrimba Review 2026](https://scrimbaguide.tech/blog/scrimba-review/) **Q: Can Scrimba replace a coding bootcamp?** For many people, yes. The Fullstack Developer Path covers similar content (108.4 hours) at a fraction of the cost. The main trade-off is losing the structured environment and career services that bootcamps provide. **Q: Is a bootcamp worth $15,000?** It depends on your situation. If you need structure, can afford the cost, and want career services, a quality bootcamp can be a good investment. If you're self-motivated and budget-conscious, Scrimba delivers equivalent education for much less. **Q: How long does it take to get hired after Scrimba?** Typical timelines are 6-12 months from starting to landing a first web development job, assuming 10-15 hours of study per week. This is similar to bootcamp timelines when you include the job search period. ## Start learning for a fraction of bootcamp cost Around 24 free courses to try. Career paths from beginner to job-ready at a fraction of bootcamp prices. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # What Is Context Engineering? (2026 Developer Guide) Source: https://scrimbaguide.tech/blog/what-is-context-engineering/ Context engineering is deciding what an AI model sees before it answers: which files, docs, examples, rules, and tools go into its context window. It replaced prompt engineering as the load-bearing skill of 2026 because today's models already parse plain requests well; what most fail on is missing information, not bad wording. I use these tools daily as an engineer who learned to code the self-taught route through 42 Network, and here's the verdict: the name is new and a little buzzy, but the job underneath it is real. It's good news for self-taught developers too, since it rewards understanding a codebase over memorizing clever phrasing. ## What context engineering actually means (in plain English) Context engineering means managing everything a model reads before it answers. A large language model has no memory of your project between sessions. It only knows what fits in its context window right now: your request, the files you attached, the rules in a config file, and whatever tools it is allowed to call. Curating that window is the whole game. Think of it like briefing a freelancer who is brilliant but has amnesia. Hand them the wrong three files and a vague ask, and they confidently build the wrong thing. Hand them the right files, your naming conventions, one working example, and a clear spec, and they get remarkably close on the first try. The difference in output has less to do with how you word the request and more to do with what you put in front of the model. In practice this shows up as project context files (the `CLAUDE.md`, `AGENTS.md`, or editor rules files that agents read automatically), the specific files you pull into a chat, and the data sources you connect. ## Where prompt engineering fits inside context engineering Prompt engineering did not die. It shrank. Wording a request well still matters, but it is now one input among several rather than the main lever. As models got better at parsing plain requests, the failure mode stopped being awkward phrasing and started being missing information. A widely shared 2026 write-up on DEV, "Context Engineering: The Skill Replacing Prompt Engineering in 2026," draws the distinction cleanly: prompt engineering is about what you say to the model, while context engineering is about what you provide it. Context engineering is the broader discipline of managing everything the model sees (its instructions, tools, memory, and retrieved data), and prompting is one technique within it. That matches what I see in daily use. When an agent gets something wrong today, rewording the prompt rarely fixes it. Giving it the file it was missing usually does. ## What the 2026 data says: the numbers behind the shift The framing is not just blog chatter. Anthropic's 2026 Agentic Coding Trends Report named context engineering "the load-bearing skill of 2026." The same report says teams that keep well-maintained context files see roughly 40% fewer errors and about 55% faster task completion. It also puts hard limits on the hype: around 60% of developer work now involves AI assistance, yet only 0 to 20% of tasks are fully delegated to agents. A human still frames the problem and curates the context. The independent numbers point the same way. The Stack Overflow 2025 Developer Survey, released in July 2025, found that about 84% of developers use or plan to use AI tools, but the single most common frustration, cited by roughly 66%, was AI solutions that are "almost right, but not quite." Trust in the accuracy of AI output fell year over year. That gap between "almost right" and right is usually a context gap: the model did not know a constraint, a convention, or a file that only lived in your head. Treat the exact percentages as directional rather than precise, since one comes from a tooling vendor and surveys move around, but the direction is consistent across sources. ## The five things a context engineer actually does Strip away the buzzword and the job breaks into five concrete tasks. - Curate the context window. Pick the right files, docs, and examples to load, and just as importantly, leave out the noise that pulls the model off track. - Write and maintain context files. A good `CLAUDE.md` or `AGENTS.md` tells the agent your conventions, your stack, and your constraints once, so you do not repeat them every session. - Wire up tools and data. The Model Context Protocol (MCP) is how agents reach your files, databases, and APIs in a standard way. Per a 2026 SitePoint guide, thousands of MCP servers now exist and the protocol was adopted by Anthropic, OpenAI, Google DeepMind, and Microsoft, which makes basic context wiring a baseline skill rather than an experiment. - Frame the problem and write specs. The adjacent 2026 workflow, spec-driven development, answers context "drift" by writing an executable spec before the code. A DEV guide on the practice shows teams treating the spec, not the prompt, as the source of truth. - Evaluate and correct the output. Because only a small share of tasks are fully delegated, reviewing what the model produced and feeding back corrections is still a human job, and the one that keeps quality up. ## Fundamentals still come first: why beginners shouldn't skip the basics Here is the part the buzzword crowd skips: you cannot curate context for code you cannot read. Context engineering is a multiplier on top of fundamentals, not a substitute for them. If you can't tell whether an agent's output is "almost right" or actually wrong, you can't do the job, and you certainly can't decide which files it needed in the first place. Anthropic's own January 2026 research on code comprehension made the same point from the other direction: developers who can read and reason about code steer these tools far better than those who only prompt. So if you are starting from zero, resist the urge to jump straight to agent orchestration. The people getting the most out of context engineering are the ones who understand HTML, CSS, JavaScript, and how a codebase fits together, then apply that judgment to what the model sees. If leaning on AI is already becoming a crutch for you, my colleague's piece on [how to learn coding without depending on AI](https://scrimbaguide.tech/blog/how-to-learn-coding-without-depending-on-ai/) is worth a read before you go further. ## How a self-taught developer can start learning context engineering You do not need a CS degree or an enterprise course to learn this. A sensible order looks like this: - Get the web fundamentals solid. Build a few things by hand first. Scrimba's MDN-endorsed [frontend developer path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) runs 81.6 hours across 13 modules, and you write the code in the lesson instead of watching someone else. - Build one small AI app end to end. Call a model from JavaScript, ground it with your own data, ship it. That single project teaches you what a context window is by making you hit its limits. Scrimba's [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) runs 11.4 hours across nine modules and already folds context engineering and MCP into the sequence. - Practice writing context files on a real project. Add a `CLAUDE.md`, watch how the agent behaves with and without it, and iterate. This is the cheapest, fastest way to build the instinct. - Take a focused course when you hit the wall. Once an app starts forgetting things, Arsala Khan's hour-long [Learn Context Engineering](https://scrimbaguide.tech/docs/courses/ai/context-engineering/) course (15 scrims) builds one chat app on the Vercel AI SDK and OpenRouter: add a system prompt, trim old messages by token count, then replace them with an AI summary so the app stops forgetting. It assumes you already build AI apps, so come to it after step two, not before. If you are a JavaScript developer weighing whether to specialize here, the guide on [becoming an AI engineer as a JS developer](https://scrimbaguide.tech/blog/how-to-become-ai-engineer-javascript-developer/) walks through the wider transition. Not sure where you fit, use the free [path finder](https://scrimbaguide.tech/tools/which-scrimba-path/) to get a starting point. ## Is it just a buzzword, or a skill worth building your 2026 around? Both. The term is partly marketing. The core practices, a clear README, a good spec, choosing the right files to share, predate the label by years, and plenty of experienced developers were "context engineering" long before anyone called it that. The specific tools will also drift, since this field changes monthly, so do not tie your identity to any one config format or MCP server. But the underlying job is real and it is not going away. When 84% of developers use or plan to use AI tools and their number one complaint is output that is "almost right," the skill that closes that gap is worth having. My advice for a self-taught developer in 2026: don't chase the buzzword, build the foundation. Learn to code well, ship one AI app, get fluent at telling a model what it needs to know. Do that and you are a context engineer, whether or not you put the phrase on your resume. ## References - [Anthropic's 2026 Agentic Coding Trends Report](https://resources.anthropic.com/2026-agentic-coding-trends-report) - the primary report behind the "load-bearing skill" framing. - [Anthropic's 2026 Agentic Coding Report coverage](https://www.claudeainews.com/news/anthropic-2026-agentic-coding-report) - the "load-bearing skill" framing, the 40%/55% context-file figures, and the 0 to 20% delegation ceiling. - [Anthropic's 2026 Agentic Coding Trends Report analysis](https://rits.shanghai.nyu.edu/ai/anthropics-2026-agentic-coding-trends-report-from-assistants-to-agent-teams/) - the shift from single assistants to agent teams and the human role of framing and evaluation. - [Context Engineering: The Skill Replacing Prompt Engineering in 2026 (DEV)](https://dev.to/gabrielhca/context-engineering-the-skill-replacing-prompt-engineering-in-2026-3lgd) - draws the distinction between what you say to the model (prompting) and what you provide it (context). - [Model Context Protocol: Complete 2026 Guide (SitePoint)](https://www.sitepoint.com/model-context-protocol-mcp/) - MCP adoption across thousands of servers. - [Spec-Driven Development in 2026 (DEV)](https://dev.to/krlz/spec-driven-development-in-2026-what-it-is-the-tooling-and-how-teams-actually-use-it-2fk2) - the adjacent spec-first workflow. - [How AI assistance impacts the formation of coding skills (Anthropic)](https://www.anthropic.com/news/AI-assistance-coding-skills) - developers who can read and reason about code steer AI tools better than those who only prompt. - [Stack Overflow 2025 Developer Survey](https://survey.stackoverflow.co/2025/) - 84% AI adoption, the 66% "almost right" frustration, and falling trust in accuracy. **Q: What is context engineering in simple terms?** It is the practice of managing what an AI model sees before it responds: the files, examples, rules, and tools you load into its context window. The model has no memory of your project, so the quality of its output depends more on the information you give it than on how cleverly you word the request. **Q: Is prompt engineering dead in 2026?** No, but it shrank. Wording a request well still helps, yet it is now one input among many. As models got better at parsing plain requests, the common failure became missing context rather than bad phrasing. Context engineering is the broader discipline of managing everything the model sees, its instructions, tools, memory, and retrieved data, and prompting is one technique within it. **Q: Do I need to know how to code to do context engineering?** Yes. You cannot decide what a model needs, or judge whether its output is correct, if you cannot read code. Context engineering multiplies your existing skill rather than replacing it. Learn web fundamentals first, then apply that judgment to what you feed the model. **Q: What is the Model Context Protocol (MCP)?** MCP is a standard way for AI agents to reach your files, databases, and APIs. A 2026 SitePoint guide reports thousands of MCP servers now exist and that it was adopted by Anthropic, OpenAI, Google DeepMind, and Microsoft, which makes connecting tools and data a baseline context-engineering skill. **Q: How long does it take to learn context engineering?** If you already build web apps, the core ideas click after one small AI project and a week of practicing context files. If you are starting from zero, budget several months for the fundamentals first. The instinct for what to include comes from shipping real projects, not from reading about it. ## Learn the skills behind context engineering Scrimba's free AI courses teach the fundamentals; the AI Engineer Path builds on them with context engineering and MCP in the curriculum. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # What Is Vibe Coding in 2026? Agents, Review Bots and Where It Breaks Source: https://scrimbaguide.tech/blog/what-is-vibe-coding-2026/ Vibe coding means describing what you want and letting AI write the code (Andrej Karpathy, X, 2025; Collins Word of the Year 2025). By September 2026 the tools run whole projects (Cursor Projects, September 10) and review their own pull requests (Cursor Security Review, September 23), but a human still checks the result. Reading code is still the skill. ## Who coined vibe coding, and why is it the 2025 word of the year? Andrej Karpathy, formerly of OpenAI and Tesla, posted on [X on February 2, 2025](https://x.com/karpathy/status/1886192184808149383): "There's a new kind of coding I call 'vibe coding', where you fully give in to the vibes, embrace exponentials, and forget that the code even exists." He described his own workflow as seeing stuff, saying stuff, running stuff, and copy-pasting stuff, and later called the tweet "a shower of thoughts throwaway." Nine months later, [Collins named "vibe coding" its Word of the Year 2025](https://blog.collinsdictionary.com/language-lovers/collins-word-of-the-year-2025-ai-meets-authenticity-as-society-shifts/), defining it as "the use of artificial intelligence prompted by natural language to write computer code." That is dictionary language for what Karpathy tweeted: talk to the model, run what it gives you, keep going. ## What changed in 2026: from chat prompts to agents that run projects Vibe coding in 2025 meant one chat window and one file at a time. By September 2026 the tools coordinate entire projects and grade their own output before you see it: | Date | Feature | What it does | Who gets it | | --- | --- | --- | --- | | 2026-08-27 | [Start from Scratch](https://cursor.com/changelog/start-from-scratch) | Cloud agents work without a connected repo, with a live in-browser preview and one-click publish to Vercel | Paid plans, early beta (enterprise can opt out) | | 2026-09-10 | [Cursor Projects](https://cursor.com/changelog/projects) | A coordinator agent that "doesn't write code itself; it plans the work, delegates it to agents that implement it, and brings the finished work back to you to check," running for months on one project | Beta, rolling out to all users | | 2026-09-23 | [Rollouts and Security Review](https://cursor.com/changelog/rollouts-and-security-reviewer) | Security Review scans every pull request for injection bugs, auth bypasses, and leaked credentials; Rollouts watches a deploy and "can also open a revert PR for review" | Teams and Enterprise plans only | ## Do these tools mean you don't need to learn to code? No. The job moved from typing code to judging it, and the vendors say so themselves. Cursor Projects hands you finished work "to check." Security Review lets you "dismiss one with a reason," which only works if you can tell a real finding from a false positive. Rollouts opens a revert PR "for review" and waits for a person to approve it. Each step assumes someone who can read the diff and judge it. You cannot approve what you cannot read. That is a narrower question than "will AI replace developers," which our [longer post on AI and junior developer jobs](https://scrimbaguide.tech/blog/do-you-need-to-learn-to-code-if-ai-writes-it/) answers with survey data. This page's answer is about vibe coding specifically: the tools got bigger and faster, and the reading skill they assume matters more than it did. ## When does vibe coding break? ("vibe coding hell") Vibe coding hell is the 2 a.m. moment your users hit an error, Sentry lights up, and your own repo reads like a foreign language, because you never wrote it line by line. The AI did not understand your business rules. It pattern-matched them. The triggers repeat across vibe-coded apps: - Async bugs that look like random UI flicker - `undefined` access that only fires on a slow network - Stale closures in React that make state lie to you - Type coercion that breaks for one customer's locale and nobody else's An agent that runs a multi-week project the way Cursor Projects does does not remove those bugs. It multiplies the amount of code you never personally wrote, so there is more of it to misread when something breaks. None of that is a prompting problem. A better prompt regenerates the same class of bug in a new shape. The fix is knowing enough JavaScript and React to read the stack trace yourself. ## How do you fix vibe coding hell? You backfill the fundamentals the agent skipped. Four steps, in order: - Read every diff before you accept it. Treat an AI pull request the way Security Review treats one: something to check, not a black box to merge. - Predict what the code does before you run it. If you cannot guess the output, you cannot debug it when the output is wrong. - Learn to read a stack trace. Our [guide to getting better at reading code](https://scrimbaguide.tech/blog/how-to-get-better-at-reading-code-2026/) is the drill for turning `Cannot read properties of undefined` into a fix instead of a re-prompt. - Keep using AI, but practise without it too. [How to keep learning to code without depending on AI](https://scrimbaguide.tech/blog/how-to-learn-coding-without-depending-on-ai/) has the method. If step 3 is the gap, the free [Learn to Code with AI](https://scrimbaguide.tech/docs/courses/ai/to-code-with-ai/) course on Scrimba is built around that same loop: paste the AI's code, run it, find what it got wrong. In its debugging lesson, Guil Hernandez hands you a broken promo-code page with three bugs and leaves the last one for you to fix. This is not about dropping AI tools. Developers who understand state and effects prompt better, review AI output faster, and stop the debugging loop instead of restarting it. ## Vibe coding vs. tutorial hell: what's the difference? Tutorial hell is passive consumption: you watch someone else type. Vibe coding hell is passive generation: you watch an AI type. Both skip the part where you struggle in short loops and build a prediction for what the code should do. The exit is the same for both: smaller exercises, hand-written predictions, reading error messages without autocomplete open. If you recognize the watching version of this loop, [how to escape tutorial hell](https://scrimbaguide.tech/docs/how-it-works/tutorial-hell/) covers the recall drills that work for vibe coders too. ## Who is vibe coding actually for? It fits prototyping, internal tools, personal projects, and experienced engineers who can audit AI output fast. It does not hold up alone in regulated systems, performance-critical paths you cannot profile, or teams without a review culture, and the 2026 team features assume that culture already exists: Security Review and Rollouts are built for a team that reviews pull requests, not a solo builder skipping that step. If you are career-switching, do not mistake a shipped demo for a passed technical screen. A demo gets you noticed; you still need to explain the tradeoffs, the tests, and the error handling behind it in an interview. Our [portfolio projects that get hired](https://scrimbaguide.tech/blog/portfolio-projects-get-hired-2026/) post is a concrete checklist for that gap, and [how to learn React in 2026](https://scrimbaguide.tech/docs/courses/react/) covers the layer where vibe-coded apps break loudest. ## Frequently Asked Questions **Q: What is vibe coding?** Vibe coding is describing what you want to an AI assistant, Claude, ChatGPT, Cursor, GitHub Copilot, and letting it generate the implementation. You steer by intent, not syntax. Collins Dictionary named it Word of the Year for 2025; the term traces to Andrej Karpathy's February 2025 post on X. **Q: Who coined vibe coding?** Andrej Karpathy, on X on February 2, 2025. He wrote that he 'fully gives in to the vibes' and later called the post a throwaway tweet. Collins Dictionary named 'vibe coding' its Word of the Year for 2025 nine months later. **Q: What is vibe coding hell?** Vibe coding hell is the moment an AI-generated codebase breaks in production and you cannot debug it because you never built a mental model of the logic. Common triggers: async bugs, undefined access, stale React state, and type coercion that only breaks for one locale. **Q: Is vibe coding bad for learning to code?** Not by itself. It speeds up prototyping and lowers the barrier to shipping a first project. It becomes a problem when it replaces understanding, especially for debugging, security, and performance. Pair it with practice that forces you to type and predict code, not just accept completions. **Q: Do I still need to learn to code if Cursor can run a whole project?** Yes. Cursor Projects (September 10, 2026) delegates the writing to agents but still 'brings the finished work back to you to check.' Someone has to be able to read that work. The tools changed what you type; they did not change what you need to understand. ## Learn to read the code your AI writes Start free and build the debugging skill that agents and review bots still assume you have. [Start free](https://scrimba.com/?via=u42d4986) ## Sources and notes - Andrej Karpathy, ["vibe coding" post](https://x.com/karpathy/status/1886192184808149383), X, February 2, 2025. - Collins Dictionary, ["Collins' Word of the Year 2025: AI meets authenticity as society shifts"](https://blog.collinsdictionary.com/language-lovers/collins-word-of-the-year-2025-ai-meets-authenticity-as-society-shifts/), announced November 6, 2025. - Cursor, ["Start from Scratch, Without a Repo"](https://cursor.com/changelog/start-from-scratch), changelog, August 27, 2026. - Cursor, ["Projects"](https://cursor.com/changelog/projects), changelog, September 10, 2026. - Cursor, ["Rollouts and Security Review"](https://cursor.com/changelog/rollouts-and-security-reviewer), changelog, September 23, 2026. - Scrimba's [Learn to Code with AI](https://scrimbaguide.tech/docs/courses/ai/to-code-with-ai/), reviewed on this site: 42 scrims opened, curriculum and lesson quotes verified against the course, September 2026. If you want the next article in the series: [how to learn coding without depending on AI](https://scrimbaguide.tech/blog/how-to-learn-coding-without-depending-on-ai/). --- # What Makes Scrimba Different: The Interactive IDE Explained Source: https://scrimbaguide.tech/blog/what-makes-scrimba-different/ The Scrimba IDE is what makes Scrimba different: instructor code is live, editable text, not a video you can only watch. Pause anywhere, take over the editor, run your change, then resume. In our analysis of 78 Product Hunt reviews, 88% of reviewers name that one feature as the reason they recommend Scrimba over Udemy, Codecademy or YouTube. Based on our analysis of 78 Product Hunt reviews for Scrimba, checked against courses reviewed inside the platform with a Pro account, September 2026. ## What Is Scrimba? Scrimba is a coding school built around one format: a lesson you pause and edit like an app instead of watching like a video. It teaches JavaScript, React, CSS, backend and AI engineering skills through that format, from single free courses up to structured [career paths](https://scrimbaguide.tech/docs/paths/), with a Pro plan gating most of the catalog. For the full picture, our [Scrimba review](https://scrimbaguide.tech/blog/scrimba-review/) covers pricing, instructors and who it fits; [what Scrimba is](https://scrimbaguide.tech/docs/intro/) covers the basics in two minutes. This page is about the one feature that makes the rest of it work. ## Who This Is For You have tried passive video courses and want to know what the interactive scrim format changes in practice. ## The Feature That 88% of Reviewers Mention One reviewer expressed the sentiment that runs through nearly every review: "I still wonder how they built it. There's no other interactive platform like Scrimba." Another: "Scrimba has revolutionized my coding journey with its ingenious platform that merges video tutorials with a live IDE." ## How Does Scrimba Work? Inside a Scrim A "scrim" is Scrimba's proprietary lesson format. It looks like a video, but the code underneath is nothing like one; see [how scrims work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/) for the full mechanics. ### What You See An instructor talks and writes code on screen, just like a YouTube tutorial. The difference is invisible until you interact with it. ### What's Actually Happening Instead of recording pixels (like a regular video), Scrimba records: - Keystrokes, every character the instructor types - Cursor movements, where they click, select, navigate - Audio, their voice explanation - File state, the complete state of all files at every moment Because the code is stored as text (not as a video frame), it remains live and editable. ### What You Can Do At any point during a lesson, you can: - Pause the timeline - Click into the code, it becomes a fully functional editor - Edit anything, change variables, add functions, delete lines - Run your version, see the output in the built-in mini-browser - Resume, the instructor continues from their version; your edits are saved separately No other coding platform builds a lesson this way. Two courses show what that looks like in practice. Bob Ziroll's free [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) runs about 15 hours across six modules, including a Chef Claude project that calls Anthropic's Claude API live in the editor, and ends with two capstone games, Tenzies and Assembly: Endgame, you edit as you build them. Kevin Powell's Pro [Learn Responsive Web Design](https://scrimbaguide.tech/docs/courses/css/responsive-web-design/) uses the same loop for CSS: he hits a broken layout on screen across 175 scrims, then pauses to fix it, and you fix it with him. ## Why This Matters for Learning ### Active vs Passive Learning Active learning, doing, experimenting, making mistakes, beats passive watching for retention. Scrimba's format makes passive consumption hard: the code sits right there, asking you to touch it. ### Zero-Friction Practice The most common barrier to coding practice is setup time. On YouTube, "following along" requires opening an editor, creating files, installing dependencies. Scrimba eliminates all of this. The editor IS the lesson. "No setup, no switching tabs, no wasting time. This small feature made a huge difference for me, I finally started practicing consistently." ### The Experimentation Loop When you can modify the instructor's code with zero risk, you naturally start experimenting: - "What happens if I change this value?" - "Can I solve this a different way?" - "What if I add an extra feature?" This experimentation builds deeper understanding than following instructions ever could. ## What Other Platforms Offer Instead | Platform | Format | Can You Edit Instructor's Code? | | --- | --- | --- | | Scrimba | Interactive video + live editor | Yes, pause and edit at any point | | YouTube | Passive video | No | | Udemy | Passive video + downloadable files | No (separate editor) | | Codecademy | Text instructions + guided editor | Partially (predefined exercises only) | | freeCodeCamp | Text instructions + test-based editor | Partially (automated test format) | | Frontend Masters | Passive video + code repos | No (clone separately) | | The Odin Project | Text-based curriculum | No (use your own tools) | Scrimba is the only platform where the video and the code editor are the same interface. ## Beyond the IDE: What Else Sets Scrimba Apart While the interactive scrim is the headline feature, reviewers also highlight: ### Engaging Instructors (15% of reviews) "The teachers are awesome... the content is abundant and of excellent quality." Scrimba's instructors include specialists like Kevin Powell (CSS), Bob Ziroll (React), and others known for clear, engaging teaching styles. ### Built-In Challenges (37% mention hands-on practice) After each section, challenges test your understanding without showing the solution first. This is the mechanism that converts watching into doing. ### Community (6.4% mention Discord) The Discord community (55k+ members) offers code reviews, study groups, and direct access to the Scrimba team, which helps on the days you would otherwise quit. ### Career Paths (25-27% mention frontend/fullstack) Rather than individual courses, Scrimba organizes content into structured career paths that take you from zero to job-ready. This removes the "what should I learn next?" anxiety. ### Scrimba Explain (new in 2026) Scrimba's newest tool sits outside the course catalog: [Scrimba Explain](https://scrimbaguide.tech/blog/scrimba-explain-review/) turns a question, a web page or your own repository into a short narrated video explainer. A free account gets 10 explainers for life and Pro gets 100 a month (details on the [Scrimba Explain reference page](https://scrimbaguide.tech/docs/how-it-works/scrimba-explain/)), and it is the clearest sign of where the platform is heading: teaching formats generated on demand, not just recorded in advance. ## The Proof Is in the Reviews Scrimba averages 4.94/5 across the 78 Product Hunt reviews in our analysis, and the number matters less than the pattern behind it: reviewers with different backgrounds keep pointing at the same feature, the interactive IDE, unprompted. Calling it "a nice feature" undersells it. It is a different way to learn, one that makes passive video feel broken once you have tried the editable kind. ## Related Reading - [How Scrimba's Interactive Scrims Work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/), technical deep dive - [How Scrimba Helps You Escape Tutorial Hell](https://scrimbaguide.tech/docs/how-it-works/tutorial-hell/), the problem this format solves - [Scrimba vs YouTube](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-youtube/), the passive vs interactive comparison - [Scrimba Review](https://scrimbaguide.tech/blog/scrimba-review/), our comprehensive platform review - [7 Real Scrimba Success Stories](https://scrimbaguide.tech/blog/scrimba-success-stories/), what users achieve with this format - [What Is Scrimba Explain?](https://scrimbaguide.tech/blog/scrimba-explain-review/), the AI explainer tested on the web, in Chrome and in Claude Code ## Try the interactive format yourself Start with a free Scrimba course and pause, edit, and run the instructor's code in your first lesson. [Try Scrimba free](https://scrimba.com/?via=u42d4986) ## Frequently asked questions **Q: What is a scrim, and how is it different from a regular video?** A scrim is Scrimba's proprietary lesson format. It looks like a video, but instead of recording pixels it records the instructor's keystrokes, cursor movements, audio, and the full state of every file at each moment. Because the code is stored as text rather than a video frame, it stays live and editable. **Q: Can I edit the instructor's code while watching a lesson?** Yes. At any point you can pause the timeline, click into the code so it becomes a fully functional editor, change variables or add functions, run your version in the built-in mini-browser, then resume. The instructor continues from their version and your edits are saved separately. **Q: Why does the interactive scrim format help you learn more than passive video?** The article points to two reasons. Active learning (doing and experimenting) retains better than watching, and Scrimba's format makes passive consumption almost impossible because the editable code is right in front of you. It also removes the setup friction of following along on YouTube, since the editor is the lesson. **Q: Besides the interactive IDE, what else sets Scrimba apart?** Reviewers in our analysis also highlight the instructors (specialists like Kevin Powell and Bob Ziroll), built-in challenges that hide the solution first, the 55k+ member Discord community, and structured career paths that replace the guesswork of choosing individual courses. --- # Frontend, Fullstack, Backend, or AI: Which Path in 2026? Source: https://scrimbaguide.tech/blog/which-coding-path-to-learn-2026/ Pick fullstack if you're a career changer who needs the widest set of doors. Pick frontend if you need visible wins fast to stay motivated. Pick backend if you can already build small things and want durable pay. Pick AI engineering only once you can already ship software on your own. There is no single best path, just the one that fits your starting point, your timeline, and how much income risk you can carry while you learn. Reviewed all four of Scrimba's paths with a Pro account, September 2026, and checked the picks against July 2026 hiring data. ## The 2026 job market changed what "which path" even means The market split into a barbell this year. Entry-level hiring collapsed while senior and AI-heavy roles boomed, so picking a path is less about which technology you like and more about which one still has a junior door you can walk through. The entry ramp narrowed hard. A 2026 developer-hiring-crisis analysis puts actual junior hiring down roughly 73% year over year even as junior job postings rose about 47%, because companies advertise junior roles and then fill them with seniors. Big Tech's junior hires fell from about 32% of new hires in 2019 to around 7% today. Those figures come from third-party trackers, not official labor stats, so read them as direction, not decimal-point precision. The counterweight matters just as much. The US Bureau of Labor Statistics still projects 15% software-developer job growth from 2024 to 2034, well above the average for all occupations. The field isn't shrinking. The first rung is. And 84% of developers now use or plan to use AI tools, per the Stack Overflow 2025 Developer Survey (released July 2025), so every path you pick now expects you to work alongside AI rather than compete with a copy of it. ## The four Scrimba paths at a glance (and what each one leads to) Scrimba organizes its catalog into four job-focused tracks, and each one maps to a distinct role and a distinct slice of the market above. The [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) builds interfaces with HTML, CSS, JavaScript, and React across 81.6 hours and 13 modules. The [Fullstack Developer Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) adds servers, databases, and APIs across 108.4 hours and 20 modules, the longest track on Scrimba. The [Backend Developer Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/) goes deep on the server side in 36.2 hours across twelve modules. The [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) is the smallest at 11.4 hours across nine modules, and it layers retrieval, agents, and model integration onto working software. Across all four, you write and run real code in the browser from the first lesson, not watch someone else type. ## Frontend: still the best on-ramp, if you go deeper than tutorials Frontend is the friendliest entry point, and it still has the most junior-friendly openings of any discipline. One June 2026 analysis of 6,138 frontend postings found that 20.7% were entry-level, the highest share of any tracked discipline, against roughly 3% for data engineers. If your first goal is getting hired, that number is the most encouraging one in this post. The catch is the word "if." AI tools generate passable interface code fast, and the top frustration developers reported in the Stack Overflow 2025 survey (66% of them) was AI output that is "almost right, but not quite." That gap is where a real frontend developer earns their keep, and what cloned tutorials never teach. Scrimba's [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) runs 81.6 hours across 13 modules and 1,493 scrims, and Mozilla's MDN reviewed the curriculum in 2024 and now recommends it, so it's built to close that exact gap rather than leave you at a finished demo. My [frontend roadmap for 2026](https://scrimbaguide.tech/roadmaps/frontend-roadmap-2026/) lays out the deeper route, and I wrote separately about [learning to code without leaning on AI](https://scrimbaguide.tech/blog/how-to-learn-coding-without-depending-on-ai/). ## Fullstack: the pragmatic hedge for most career changers Fullstack is the pragmatic default for most career changers because it gives you the widest set of doors to knock on when any single specialization contracts. When frontend roles get absorbed into broader jobs and backend roles ask for depth you don't have yet, the person who can credibly do both stays employable. The trade: fullstack means learning more before you're hireable, and it's easy to end up shallow on both ends. Fix that by going deep on one side first, usually the frontend, then treating the other as your range instead of half-learning both at once. Scrimba's [Fullstack Developer Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) is built around that order: 108.4 hours across 20 modules, starting with the Hometown Homepage and Blackjack builds on the frontend side before it hands you Build a Node API and Build a Fullstack Node App, then closes with 5.3 hours of Launching Your Career. I compared the two routes directly in [Scrimba's learning paths](https://scrimbaguide.tech/docs/paths/), and if you're switching careers, [best Scrimba courses for career changers](https://scrimbaguide.tech/blog/best-scrimba-courses-career-changers/) makes the fuller case for this hedge. ## Backend and the TypeScript pay premium hiding in the data Backend trades a steeper learning curve for more durable demand and better pay, and there's a specific, learnable lever inside the numbers: TypeScript. That same June 2026 frontend analysis found roles listing TypeScript paid a median of $147,200 versus $120,000 for JavaScript-only roles, a premium of roughly $27,200. Typed, testable code is harder to fake and harder to automate away, which is why the premium exists. TypeScript isn't a niche bet either. It became the most-used language on GitHub in 2025, per GitHub's Octoverse 2025 report, overtaking both JavaScript and Python. Pair that with the BLS projection of about 15% software-developer growth from 2024 to 2034, and backend work rewards the difficulty it asks of you. AI assistants help least with the parts that matter here, data modeling and concurrency, so that scarcity is the job security. Scrimba's [Backend Developer Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/) runs 36.2 hours across twelve modules on Node, Express, SQL, and TypeScript, taught by Tom Chant, and it opens with a Super Challenge that has you wire up a live stock ticker from a fake API before you get any hand-holding. If this is your lean, add a [TypeScript course](https://scrimbaguide.tech/docs/courses/typescript/) early, and read my [Scrimba backend path review](https://scrimbaguide.tech/blog/scrimba-backend-path-review/) for how the track is structured. ## AI engineer: the fastest-growing path, and who it's for AI engineering is the fastest-growing path in the field and the wrong first path for most beginners. LinkedIn's Jobs on the Rise 2026 ranked AI Engineer the number one fastest-growing US role in 2026. One 2026 analysis estimates postings up about 143% year over year and a demand-to-supply gap around 3.2 to 1, roughly 1.6 million open roles against about 518,000 qualified candidates. Pay runs high too: the national median for the role is around $145,000 (US BLS), rising to roughly $207,000 in the highest-paying metros such as San Jose. Here's the part the salary charts bury. Almost all of those openings assume you can already ship software. They're senior and mid-level roles for engineers adding an AI layer, not first jobs for people learning to code, and the junior rung is the thinnest of the four paths. AI engineering works far better as a second path than a starting point: learn to build and deploy a real application first, then add retrieval, agents, and model plumbing on top. Scrimba's [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) is built for exactly that sequence: 11.4 hours across nine modules and 162 scrims, taught by a rotating cast of Scrimba instructors, where you build a ReAct agent by hand, run RAG search over your own data, and deploy a Node app to Render. A JavaScript or TypeScript foundation carries you a long way into that work without a full Python detour first. I mapped the route in the [Scrimba AI engineer path guide](https://scrimbaguide.tech/blog/scrimba-ai-engineer-path-guide/). ## A decision framework: match the path to your goal, timeline, and risk tolerance The right path depends on three things about you, not the market: whether you can already ship software, what kind of feedback keeps you going, and how long you can go without income while you learn. Answer those and the choice mostly makes itself. | Your situation | Pick | Why | | --- | --- | --- | | Starting from zero, need to be hireable soon | Fullstack, beginning on the frontend | Widest set of doors when one specialization contracts | | Need visible progress to avoid quitting in month two | Frontend | Fastest visual feedback, highest entry-level share of postings | | Can already build small things, want pay and durability | Backend, with TypeScript early | Steeper curve but harder for AI to automate | | Already work as an engineer | AI, as a second specialization | Highest-paying, fastest-growing roles, but almost none are entry-level | If you want a faster read on your own situation, my [Path Advisor](https://scrimbaguide.tech/tools/which-scrimba-path/) asks a few questions and points you at one of the four tracks. This post is the path-decision guide; for the deeper job-market data on its own, my companion post on [which developer specialization has the best job market](https://scrimbaguide.tech/blog/developer-specialization-job-market-2026/) breaks it down by volume, hiring ease, and pay. ## What order to learn in, and how to schedule it once you've chosen Whatever path you land on, the first block is the same: HTML, CSS, and JavaScript fundamentals, because all four tracks stand on them. Get comfortable building and debugging small pages before you branch. From there, frontend adds React, fullstack adds a backend and a database, backend goes deep on data and TypeScript, and AI engineering layers models onto an app you can already deploy. Skipping the fundamentals to chase the shiny end of a path is the most common way people stall. Scheduling beats intensity. An hour a day you keep outruns a heroic weekend you abandon by week three, especially in a market where the differentiator is a portfolio of things you built and understand. Scrimba's [study plan](https://scrimbaguide.tech/docs/paths/study-plan/) turns a chosen path into a week-by-week cadence that removes the daily "what do I do next" decision. Pick the path, then let the schedule carry it. ## Two things the salary charts don't tell you The sharpest figures here, the 73% hiring drop, the 143% AI growth, and the salary splits, come from third-party analyses, not official statistics, and different trackers report different values for the same trend. Treat them as direction. The primary-sourced numbers are narrower and hold up: BLS still projects 15% growth, TypeScript is GitHub's most-used language, LinkedIn ranks AI Engineer number one, and 84% of developers now use AI tools. A learning path is not a job. In a market this tight at the entry level, finishing a track is the price of admission, not the finish line. What converts is shipped projects you can explain, plus the work of applying and networking. Scrimba is one good on-ramp, not the only one: if lectures suit you better than interactive coding, freeCodeCamp and The Odin Project are strong free routes, and learning well anywhere beats paying for a format that doesn't click. The vibe-coding trap is real too, which is why I wrote up going from [how to learn coding without depending on AI](https://scrimbaguide.tech/blog/how-to-learn-coding-without-depending-on-ai/), and the entry ramp gets its own look in [the junior developer job market in 2026](https://scrimbaguide.tech/blog/junior-developer-job-market-2026/). ## References - [US Bureau of Labor Statistics, Software Developers](https://www.bls.gov/ooh/computer-and-information-technology/software-developers.htm) - the 15% projected job growth from 2024 to 2034. - [Stack Overflow 2025 Developer Survey](https://survey.stackoverflow.co/2025/) - 84% AI adoption and the 66% "almost right, but not quite" frustration. - [Frontend developer skills in 2026 (June 2026 analysis)](https://medium.com/@interviewstack.io.2026/frontend-developer-skills-in-2026-1-in-5-openings-is-entry-level-0efa09c2c17d) - the 20.7% entry-level share and the TypeScript pay premium. - [AI Engineer demand 2026](https://www.futureproofing.dev/resources/ai-talent-gap/ai-engineer-demand-2026) - the 143% growth, 3.2:1 gap, and average-salary estimates. - [Fastest-growing AI roles in 2026](https://www.herohunt.ai/blog/fastest-growing-ai-roles-in-2026-data-and-rankings/) - LinkedIn's Jobs on the Rise ranking of AI Engineer as number one. - [Developer hiring crisis 2026](https://byteiota.com/developer-hiring-crisis-2026-40-worse-junior-drops-73/) - the junior-hiring drop against rising junior postings. - [GitHub Octoverse 2025](https://github.blog/news-insights/octoverse/octoverse-a-new-developer-joins-github-every-second-as-ai-leads-typescript-to-1/) - TypeScript overtaking JavaScript and Python as the most-used language on GitHub. **Q: Which coding path should I learn first in 2026?** For most beginners, start with the frontend path, then branch into fullstack. Frontend has the most junior-friendly openings, with one June 2026 analysis putting its entry-level share at 20.7%, the highest of any discipline, and it gives fast visual feedback. Add backend once you can build small apps, and treat AI engineering as a second path. **Q: Is AI engineering a good first coding path for beginners?** Usually not. AI Engineer topped LinkedIn's Jobs on the Rise 2026 as the fastest-growing US role, but most of those openings want people who can already ship software. The junior rung is the thinnest of the four paths, so AI engineering works better layered on top of fullstack or backend skills than learned from zero. **Q: Which coding path pays the most in 2026?** AI engineering has the highest ceiling, with a national median around $145,000 (US BLS) that rises to roughly $207,000 in the highest-paying metros such as San Jose. Inside web roles, TypeScript is the lever: one June 2026 analysis found TypeScript frontend roles paid a median of $147,200 versus $120,000 for JavaScript-only, a premium of roughly $27,200. Harder-to-fake work pays more. **Q: Is it still worth learning to code in 2026 given AI?** Yes, with a caveat. The US Bureau of Labor Statistics still projects about 15% software-developer growth from 2024 to 2034, and 84% of developers use or plan to use AI tools per the Stack Overflow 2025 survey. What changed is that employers now want people who understand and can debug code, not just prompt it. **Q: How do I choose between frontend, fullstack, backend, and AI paths?** Match the path to your goal, timeline, and income risk. A career changer who needs a job soon should pick fullstack. Someone who needs visible wins should start frontend. Someone who can already build and wants durable pay should lean backend. An engineer who already ships should add AI. The Path Advisor turns a few questions into a recommendation. ## Pick a path and start building this week Match yourself to a track with the Path Advisor, then start free on Scrimba with hands-on projects instead of passive tutorials. [Try Scrimba free](https://scrimba.com/?via=u42d4986) --- # Scrimba Pro Subscription: Why Users Keep Renewing (2026) Source: https://scrimbaguide.tech/blog/why-i-keep-renewing-scrimba-pro/ Scrimba Pro subscribers renew past year one because Scrimba keeps shipping career-relevant courses, the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) and [Backend Developer Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/) among them, and because the pause-and-edit lesson format stays useful for picking up new tools at work. Trustpilot and r/learnprogramming both back this up. Course and path specifics below come from our own Pro-account reviews of each one; retention patterns come from Trustpilot and r/learnprogramming. ## Long-Term Value Verdict 4.5/5 Scrimba Pro holds its value after year one because new career-relevant courses keep shipping, the AI Engineer Path and Backend Path among them. It stops being a bootcamp replacement and turns into ongoing professional development. ### Pros - New courses added regularly (AI, Backend, React 19) - Excellent for learning new frameworks quickly - Community access for ongoing networking ### Cons - Subscription model required to keep access [Try a scrim in your browser (no signup)](https://scrimba.com/s0v687325e?via=u42d4986) [Trustpilot](https://www.trustpilot.com/review/www.scrimba.com) sits around 4.3 out of 5, and r/learnprogramming threads say the same thing in plainer words: the people who renew aren't paying for the first-year curriculum anymore. They're paying for the format, plus whatever shipped since they signed up. ## What does Scrimba Pro include? Pro unlocks every career path, Frontend (81.6 hrs), Fullstack (108.4 hrs), the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) (11.4 hrs), and the [Backend Developer Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/) (36.2 hrs), plus 73+ standalone courses across React, JavaScript, TypeScript, Python, CSS, AI, and backend work. Solo projects come with design specs for a portfolio, Discord gives you code reviews and a weekly Town Hall, and finished paths earn a certificate. New courses land on a regular cadence. See the [Pro vs Free comparison](https://scrimbaguide.tech/docs/pricing/pro-vs-free/) for the full breakdown. ## Is Scrimba Pro worth it after year one? Year one goes to a career path. Frontend or Fullstack takes 10 to 15 hours a week and most of that first year, and it's the reason people sign up in the first place. Year two is where the subscription earns a second look, and where the paths above matter most. Our review of the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) found it runs 11.4 hours across nine modules and 162 scrims, opened by Tom Chant, with Arsala Khan teaching the open-source-models and context-engineering modules and Bob Ziroll, Guil Hernandez, and Per Borgen covering the rest. React 18 knowledge ages into React 19 patterns, TypeScript becomes worth knowing as projects grow, and the [Backend Developer Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/), 36.2 hours of Node, Express, SQL, and security led by Tom Chant, turns a frontend-only subscriber into a fullstack one without re-doing anything they already learned. Working engineers on Trustpilot make the same point about the format itself: Scrimba doesn't graduate you. The pause-and-edit loop that taught you your first framework is the same loop you use to pick up the next one, faster than documentation or a YouTube tutorial, because the code in front of you is yours to run. If you're weighing Pro specifically for year-two learning, [start the AI Engineer Path](https://scrimba.com/ai-engineer-path-c02v?via=u42d4986) and judge it on that alone. New modules ship roughly quarterly, so it's the track that changes the most between renewals. ## How much does Scrimba Pro cost long-term? Annual billing lands in the low hundreds per year, close to Codecademy Pro and well under Frontend Masters. A US bootcamp runs two orders of magnitude higher, so the renewal decision isn't "is Pro expensive." It's "am I using the format enough to justify the line item." Scrimba also applies regional purchasing-power pricing automatically, a reason readers in lower-income regions cite often for staying subscribed. Check [the official pricing page](https://scrimba.com/our-pricing?via=u42d4986) for your regional rate; we don't quote a figure here because it moves by region and promotion. See the [Scrimba vs Bootcamps cost analysis](https://scrimbaguide.tech/docs/pricing/scrimba-vs-bootcamps/) and the broader [pricing breakdown](https://scrimbaguide.tech/docs/pricing/) for the numbers behind that comparison. ## When is Scrimba Pro not worth renewing? - You only need one course. Check the [free tier](https://scrimbaguide.tech/blog/best-free-scrimba-courses/) first; it may already cover it. - You study less than an hour a week. The value comes from consistent use, and the free tier suffices at that pace. - You're a senior developer. Scrimba's content targets beginners through mid-level. Advanced system design or architecture work is better served elsewhere. ## Why do long-term subscribers keep renewing? Four reasons show up again and again in Trustpilot and Reddit threads: - The interactive format has no real substitute. Once you've coded inside a lesson instead of watching one, passive video feels like a downgrade. - New content keeps appearing. The [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/), the [Backend Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/), and an updated React curriculum all shipped after most subscribers' first year. - The community is active, not decorative. Code reviews, study groups, and direct instructor access happen in the Discord every week. - The cost holds up against alternatives. Billed annually, it often lands below common streaming services per month while delivering a structured curriculum instead of entertainment. ## See what Pro subscribers get Try Scrimba Pro and access 73+ interactive courses, career paths, and the Discord community. [Try Scrimba free](https://scrimba.com/?via=u42d4986) ## Frequently asked questions **Q: Is Scrimba Pro worth renewing after the first year?** Yes, for most long-term subscribers. Trustpilot and r/learnprogramming both show people renewing not for the first-year curriculum but for the steady cadence of new career-relevant courses, the AI Engineer Path, the Backend Developer Path, and updated React 19 material among them. Pro turns from a bootcamp replacement into ongoing professional development. **Q: What keeps long-term subscribers paying for Scrimba Pro?** Four reasons come up repeatedly: the interactive coding-inside-the-lesson format that no other platform matches, a regular stream of new courses, an active Discord with code reviews and study groups, and a cost that often lands below common streaming services on the regional pricing page. **Q: Is Scrimba Pro worth it long-term for experienced developers?** Working engineers on Trustpilot say the platform doesn't graduate them; they keep returning to pick up new frameworks fast, using the same pause-and-edit loop that worked for them as beginners. The content still targets beginners through mid-level, though, so senior developers wanting advanced system design or architecture work are better served elsewhere. **Q: Do you keep access to Scrimba courses if you cancel Pro?** No. Pro is a subscription, so full access to every path, course, and the Discord community depends on an active plan. If you only need one course, or you study an hour or two a week, check the free tier first. See the [refund policy breakdown](https://scrimbaguide.tech/docs/pricing/refund-policy/) for what happens right after you cancel. Scrimba also applies regional purchasing-power pricing automatically, a common reason readers in lower-income regions cite for staying subscribed. --- # Contact Us Source: https://scrimbaguide.tech/contact/ Have a question about a Scrimba course? Found a bug on our site? Just want to say hi? We'd love to hear from you. ## Email You can reach us directly at: [hello@scrimbaguide.tech](mailto:hello@scrimbaguide.tech) We try to respond to all inquiries within 48 hours. ## Around the web Scrimba Guide is run by Yassine El Haddad. You can find him here: - [LinkedIn](https://www.linkedin.com/in/yassine-el-haddad/) - [GitHub](https://github.com/yel-hadd) Looking for Scrimba's own community? [Join the Scrimba Discord](https://scrimba.com/discord). - Email - Around the web --- # What's new on Scrimba? Source: https://scrimbaguide.tech/docs/changelog/ Scrimba shipped a run of changes through 2026: Scrimba Explain moved from open beta to fixed monthly quotas, [Learn Python](https://scrimbaguide.tech/docs/courses/python/learn-python/) was rebuilt with a new teacher, and the [Backend Developer Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/) left beta. AI Instant Feedback landed on challenges, React 19 coverage arrived in its own course, and Bootcamp projects now run on real Git and GitHub workflows. For what's still confirmed but not yet shipped, see [the 2026 roadmap](https://scrimbaguide.tech/blog/scrimba-roadmap-whats-coming/). Sourced from Scrimba's public roadmap, blog and docs, checked against the courses we've reviewed. ## Seen by 21 September 2026 - Plans: Scrimba's launch articles in August described [Scrimba Explain](https://scrimbaguide.tech/docs/how-it-works/scrimba-explain/) as "free during open beta". By 20 September the docs limits page instead sets fixed quotas: a free account gets 10 explainers for life, Pro gets 100 a month. Follow-ups and Go deeper each count as one; drafts from ChatGPT or a coding agent stay free until claimed. Scrimba has not published a date for the change. - Feature: An EXPLAIN button in the header of every scrim sends the lesson, your highlighted code and the teacher's transcript to Explain, so you can ask about the code in front of you without leaving the lesson. Scrimba's docs describe the button but do not say when it shipped. - Catalog: [Intro to Model Context Protocol](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/) gained four AI-generated explainer scrims in September 2026, each 75 to 90 seconds with a quiz and the line "Explain is AI and can make mistakes". - Integrations: The "Explain by Scrimba" Chrome extension turns the page you are reading into an explainer; the @Explain app inside ChatGPT returns answers as video; Claude Code, Codex and any MCP agent can build explainers from a repository through Scrimba's MCP endpoint. Scrimba's docs describe all three but do not date them. ## August 2026 - Course relaunch: [Learn Python](https://scrimbaguide.tech/docs/courses/python/learn-python/) was replaced at the same URL by a 4.1 hour course from Treasure Porth built around three terminal apps. It covers less than Olof Paulson's 5.6 hour course it replaced, which stays online at a separate URL as "the old course". - Launch: Scrimba Explain went public on Product Hunt on 13 August 2026. Type a question, attach a document, or point it at your code and it builds a narrated video with diagrams and a quiz. Our [tested review](https://scrimbaguide.tech/blog/scrimba-explain-review/) covers what it is good at. ## Early 2026 - Course update: [What's New in React 19](https://scrimbaguide.tech/docs/courses/react/whats-new-in-react-19/) covers the newest React 19 patterns (Server Components, Actions, the `use` hook). These live in that dedicated course rather than in the foundational [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/). - Feature: Bootcamp group projects use Git and GitHub (branching, pull requests, code review), so you practice a real team workflow. ## Late 2025 - Launch: [Backend Developer Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/) officially launched out of beta. - New Courses: - [Learn Context Engineering](https://scrimbaguide.tech/docs/courses/ai/context-engineering/) - [Build a Support Agent with Vercel AI SDK](https://scrimbaguide.tech/docs/courses/ai/a-support-agent-with-vercel-ai-sdk/) - [Learn SQL](https://scrimbaguide.tech/docs/courses/backend/sql/) ## Early 2025 - New Feature: AI-powered Instant Feedback on challenges launched in February 2025, giving you hints when you're stuck. In a course these scrims carry a "Challenge with Instant Feedback" icon; [Learn Next.js](https://scrimbaguide.tech/docs/courses/javascript/nextjs/) now has 80 of them. ## 2024 - Feature: The Scrimba 2.0 editor shipped in July 2024, with major performance improvements over the original platform. ## Ongoing - Weekly Town Halls in Discord. - Regular "Code Review of the Week" videos. ## Where to check for official details For support and the latest platform details straight from Scrimba, visit the [Scrimba Help Centre](https://scrimba.helpscoutdocs.com). ## Jump in while the platform is moving Try free scrims today; upgrade to Pro when you want every new course and all four paths. [Try Scrimba free](https://scrimba.com/?via=u42d4986) ### Related Guides - [Scrimba Roadmap: What's Coming](https://scrimbaguide.tech/blog/scrimba-roadmap-whats-coming/) - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) - [Scrimba FAQ](https://scrimbaguide.tech/docs/faq/) --- # Scrimba vs Alternatives Source: https://scrimbaguide.tech/docs/comparisons/ Scrimba beats most course platforms for learners who want to type real code inside every lesson, not just watch one: each scrim pauses at a live-editor challenge and plays the solution only after you answer. It covers frontend, fullstack, backend and AI paths, a large free tier, and Discord support. It skips Java, C#, Go and university credentials. Most platforms optimize for watching or reading. You finish the lessons and still freeze at a blank editor. Scrimba forces the opposite: the challenge lands as numbered comments inside the file, the video pauses, and you type the answer into that same editor before it plays back the solution. ## When Scrimba is the better primary choice Choose Scrimba if you want to: - Ship code inside every lesson. [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) alone stops for 140+ challenges, and its newer drills carry a "Challenge with Instant Feedback" marker: an AI checks your solution against the spec so you do not have to watch Per's answer first. - Follow structured paths toward frontend, fullstack, backend, or AI engineering roles. - Go deep on React, JavaScript, and modern AI topics in one curated catalog. - Lean on an active Discord (basic access free, Pro-only channels for code review) while you build portfolio projects. Choose a different primary resource if you: - Must learn languages Scrimba does not cover (Java, C#, Ruby, Go, Rust as a main goal). - Want purely text-and-links curricula (documentation-style self-direction). - Need a university-branded credential for HR checkboxes (Coursera-style programs). - Will not pay anything ever, freeCodeCamp and The Odin Project are the usual starting points (Scrimba still offers substantial free courses; see [Is Scrimba free?](https://scrimbaguide.tech/docs/pricing/pro-vs-free/)). ## Deep-dive comparisons | Competitor | Best when you need… | Main tradeoff vs Scrimba | Guide | | --- | --- | --- | --- | | Udemy | Niche one-off topics | Marketplace quality varies vs curated interactive paths | [Scrimba vs Udemy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-udemy/) | | Codecademy | Syntax drills, many languages | Text-first drills vs pause-and-code video scrims | [Scrimba vs Codecademy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-codecademy/) | | YouTube | Free breadth, quick clips | Passive watch risk vs forced in-lesson coding | [Scrimba vs YouTube](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-youtube/) | | freeCodeCamp | $0 budget, text certifications | Text + tests vs instructor-led interactive video | [Scrimba vs freeCodeCamp](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-freecodecamp/) | | The Odin Project | Free, project-heavy self-direction | Curated free links vs guided in-browser scrims | [Scrimba vs The Odin Project](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-odin-project/) | | Boot.dev | Backend CS fundamentals (Python, Go) | Gamified backend theory vs interactive frontend-focused scrims | [Scrimba vs Boot.dev](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-boot-dev/) | | Zero to Mastery | Cohort-style bootcamp with one lead instructor | Cohort scaffolding vs truly self-paced scrims | [Scrimba vs ZTM](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-zerotomastery/) | | Frontend Masters | Expert workshop depth | Passive workshop video vs structured beginner-to-job paths | [Scrimba vs Frontend Masters](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-frontendmasters/) | | Treehouse | Video + quiz style | Separate practice vs code inside the lesson | [Scrimba vs Treehouse](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-treehouse/) | | Coursera | Formal credentials, broad subjects | Academic pacing vs daily typing practice for web roles | [Scrimba vs Coursera](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-coursera/) | | Pluralsight | Company-paid team learning, cert prep | Enterprise L&D scale vs individual web + AI paths | [Scrimba vs Pluralsight](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-pluralsight/) | | Educative | Interview / system design text tracks | Text + embedded playgrounds vs guided video scrims | [Scrimba vs Educative](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-educative/) | | Fireship | One charismatic instructor over a curated platform | Short-form Jeff Delaney brand vs long-form multi-instructor paths | [Scrimba vs Fireship](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-fireship/) | | ChatGPT / free AI | Instant answers to any question | Instant text answers with no sequence vs paths that make you type (and [Scrimba Explain](https://scrimbaguide.tech/docs/how-it-works/scrimba-explain/) for video answers inside lessons) | [Scrimba vs ChatGPT](https://scrimbaguide.tech/blog/scrimba-vs-chatgpt-learn-to-code/) | ## Decide in three questions - Budget - $0: [freeCodeCamp](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-freecodecamp/) or [The Odin Project](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-odin-project/), plus Scrimba's [free courses](https://scrimbaguide.tech/docs/courses/) to feel the scrim format. - Subscription: [Scrimba Pro](https://scrimbaguide.tech/docs/pricing/) or Codecademy Pro, compare format in the guides above. - Premium depth: Frontend Masters or similar once you already ship apps. - How you learn - Watch-only: Udemy or Frontend Masters can work, pair with building, or you risk tutorial sprawl. - Read and grind: freeCodeCamp, Odin, or docs-heavy tracks. - Type inside the lesson: Scrimba. See [How Scrims Work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/), or the [Learn JavaScript review](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) for what a lesson looks like from inside. - End goal - First dev job (web): Scrimba [Career Paths](https://scrimbaguide.tech/docs/paths/) or Odin-style portfolios, often both over time. - One specific tool: Udemy's marketplace breadth. - Degree or university certificate: Coursera / formal programs. ## Frequently asked questions **Q: Is Scrimba better than Udemy?** For web development and staying out of passive-watch mode, we give Scrimba the edge: you code inside lessons, and paths bundle projects employers care about. Udemy wins when you need a niche Scrimba does not cover (games, mobile, marketing tech) or a one-off lifetime purchase. **Q: Can I use Scrimba for free?** Yes. Learn JavaScript, Learn React and Learn HTML and CSS are free in full, every module and every challenge. What Pro gates inside them is the Solo Projects (built from a design file and a written spec, no walkthrough), the certificates, the career paths and the Pro-only Discord channels. That is enough to judge whether scrims fit you before paying. **Q: Does Scrimba replace a bootcamp?** For many people, yes on skills: career paths cover much of what expensive bootcamps teach. You still supply the discipline and job-search hustle; no cohort tracks your attendance. **Q: Can I just learn with ChatGPT instead?** You can get answers from ChatGPT, but it will not sequence a curriculum or make you type. Scrimba covers the answers side too: press EXPLAIN in any lesson and Scrimba Explain builds a narrated video from that scrim (10 for life on Free, 100 a month on Pro). See [Scrimba vs ChatGPT](https://scrimbaguide.tech/blog/scrimba-vs-chatgpt-learn-to-code/). ## Try Scrimba free before you commit Open a free course, pause the video, edit the code, and see if this is your learning style, no card required. Use our partner link to get 20% off the Pro plan. [Claim 20% off Scrimba Pro](https://scrimba.com/our-pricing?via=u42d4986) ### Related Guides - [Scrimba Review](https://scrimbaguide.tech/blog/scrimba-review/) - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) --- # Scrimba vs Boot.dev Source: https://scrimbaguide.tech/docs/comparisons/scrimba-vs-boot-dev/ Scrimba and Boot.dev barely compete. Scrimba teaches frontend, fullstack, and AI engineering through interactive video lessons you pause and edit. Boot.dev teaches backend fundamentals, Python, Go, and computer science basics, through gamified quests. Boot.dev runs about $49 per month or $349 per year [(Boot.dev Pricing)](https://www.boot.dev/pricing); Scrimba Pro annual lands in a similar bracket and adds a real free tier. ## Decide in one minute Pick the track you want, not the platform that looks more polished on Twitter. If you cannot answer "do I want to write UI code or backend code" yet, start on Scrimba's free tier because the cost is zero. ## The Verdict Depends on your target role Scrimba wins for frontend, fullstack, and AI engineering jobs. Boot.dev wins for backend-with-CS-fundamentals jobs (Python or Go shops). If you genuinely want both, run Scrimba's Fullstack Path first and add Boot.dev once you know JavaScript is not enough for the roles you are interviewing for. ### Pros - Scrimba: Pause and edit code inside the video lesson - Scrimba: Around 24 free courses, no credit card - Scrimba: Strong 2026 AI engineering track (agents, RAG, MCP, Vercel AI SDK) - Boot.dev: Genuine CS fundamentals (Big-O, data structures, algorithms) - Boot.dev: Gamified XP keeps daily streaks alive for learners it suits ### Cons - Scrimba: Backend path is JavaScript-only, no Go or deep algorithms - Boot.dev: No meaningful free tier; you are committing on third-party reviews - Boot.dev: Frontend coverage is minimal; not a JS/React resource - Boot.dev: RPG framing is polarizing; some adult learners find it infantilizing [Try Scrimba free](https://scrimba.com/s0v687325e?via=u42d4986) ## The three decisions that matter ### 1. Frontend-first vs backend-CS-first The market in 2026 has two distinct entry-level lanes. Frontend and fullstack roles are dominated by React, Next.js, TypeScript, and increasingly AI integration via the Vercel AI SDK and similar tools. Backend roles in Python or Go shops expect HTTP fluency, SQL, Docker, and at least a working understanding of data structures. Scrimba's curriculum is built for the first lane. 10+ React courses, 30+ JavaScript courses, 12 AI engineering courses, and a [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) that runs 81 hours. The [Backend Developer Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/) exists (Node.js, Express, SQL, TypeScript) but it is short at around 39 hours and stays inside the JavaScript ecosystem. Boot.dev is built for the second lane. The official Backend Developer Path teaches Python, Go, SQL, HTTP, Docker, and CS fundamentals across roughly 23 courses and 8 projects, with most beginners taking around 12 months end to end [(Boot.dev Pricing)](https://www.boot.dev/pricing). It is structured more like a self-paced CS minor than a course library. If your target job posting says "React, TypeScript, Next.js," Scrimba. If it says "Go, Python, Postgres, Docker," Boot.dev. If you have not picked, do not pay either subscription yet. ### 2. Gamified XP vs structured path Boot.dev wraps its curriculum in an RPG layer: XP for finishing exercises, streaks for showing up daily, levels, achievements, a fantasy framing on top of computer science. Reviewers split sharply on this. Some describe it as "exactly the daily nudge I needed" and credit the streak system with finishing a path they had abandoned three times elsewhere. Others find the XP-to-effort ratio off (a six-hour lesson awarding the same XP as a 15-minute one), or find the RPG framing infantilizing for an adult learning a professional skill [(Trustpilot reviews)](https://www.trustpilot.com/review/www.boot.dev). Both reactions are common; neither is wrong. The gamification is not a universal good and pretending otherwise gets people six months into a subscription they resent. Scrimba's structure is conventional in shape: courses grouped into career paths, a checklist of modules, a certificate at the end. The motivation lever is the format itself, not gamification. You hit play, the instructor starts typing, you pause and write code, you keep going because the loop is short. The test is whether streaks and XP get you to open the tab on a Tuesday night. If yes, Boot.dev's gamification is a real feature. If you would resent being asked to "level up" while studying HTTP, a conventional curriculum like Scrimba's is the calmer choice. ## Who should pick Boot.dev specifically The five learners who get the most from Boot.dev: - You bounced off Codecademy or freeCodeCamp because you stopped opening the tab. If gamified streaks have worked for you in other apps (Duolingo, fitness apps), the same mechanic will likely work here. - You want a backend role at a Python or Go shop. Stripe, HashiCorp, Twitch infra, Uber, Cloudflare, plus thousands of smaller companies pay well for Go. Boot.dev is one of the few non-bootcamp resources that takes Go seriously end to end. - You want to interview at companies that ask algorithm questions. Boot.dev's CS fundamentals (data structures, Big-O, recursion, trees, graphs) directly map to LeetCode-style screens. Scrimba has one 2.5-hour [Data Structures and Algorithms](https://scrimbaguide.tech/docs/courses/javascript/data-structures-and-algorithms/) course (Big O, linked lists, trees, graphs, eleven challenges with Vitest test files, Pro after the first four scrims). It is a primer, not a track. If interview prep specifically is the goal, [Scrimba vs Educative](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-educative/) covers Educative's Grokking series, built for exactly that. - You learn well from one opinionated linear path and dislike browsing a catalog. Boot.dev tells you what to do next; you do it. If decision fatigue is the thing that derails you, a single track helps. - You are okay paying for the full year up front. Boot.dev's free tier will not get you far enough to evaluate the curriculum properly. You are effectively committing on faith based on third-party reviews. If none of those five fit, you are probably better off with a different platform. If three or more fit, Boot.dev is genuinely a strong choice and Scrimba is not its replacement. ### 3. Python and Go focus vs JS and TS focus The language stack is the cleanest split between these platforms. Boot.dev's primary languages are Python and Go, with SQL throughout. JavaScript is minimal. Scrimba is primarily JavaScript and TypeScript. Python is one course, Treasure Porth's 4.1-hour [Learn Python](https://scrimbaguide.tech/docs/courses/python/learn-python/) (free, three small terminal apps: an expense splitter, a word game and a karaoke queue, with a Runner pane rather than a browser preview). The AI engineering track is JavaScript: [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) uses the OpenAI JavaScript library against Groq, OpenRouter or OpenAI. This is not a small detail. The job market in 2026 still pays well for both stacks, but the day-to-day work is genuinely different. Go backends use different patterns than Node backends. Python data work uses different libraries than JS data work. Pick the language stack you want to spend the next two to five years writing. ## Where Boot.dev clearly wins - CS fundamentals. Algorithms, data structures, Big-O, recursion, trees, graphs, linked lists. Scrimba's single DSA course is a 2.5-hour primer. - Go. If you want to write Go backends, Boot.dev is one of the few non-bootcamp resources that teaches it well end to end. - Curriculum depth in one path. Boot.dev's Backend Path is roughly 12 months of structured study, longer than any single Scrimba path. The opinionated single-track design is a feature if you want to be told what to study next. - Linux, Docker, CI/CD basics. Real backend operational concerns rather than a quick mention. - Gamification for low-motivation learners. If streaks and XP help you, that is genuine value. Sources: [Boot.dev Pricing](https://www.boot.dev/pricing), [Boot.dev Curriculum (GitHub)](https://github.com/bootdotdev/curriculum), [CourseFacts Boot.dev Review 2026](https://www.coursefacts.com/guides/boot-dev-review-2026). ## When Scrimba clearly wins - You want a React, Next.js, or fullstack JavaScript role. - You want to build AI-powered apps in 2026 (agents, RAG, MCP, LLM integration). Boot.dev has almost no coverage here. - You learn better when you can pause a video and edit the instructor's code without leaving the player. - You want to try the platform before paying. Scrimba's free tier (around 24 full courses) is real. Boot.dev's is not. - You are still deciding between frontend and backend and want the cheapest path to find out which one you like. | Feature | Scrimba | Boot.dev | | --- | --- | --- | | Primary focus | Frontend, fullstack, AI engineering | Backend, CS fundamentals | | Languages | JS, TypeScript, Python, HTML/CSS | Python, Go, SQL, C (for CS fundamentals) | | Teaching format | Video scrims that pause at each challenge; you type in the same editor | Gamified browser exercises with XP and quests | | Monthly price | Check current pricing | ~$49/mo or ~$349/yr | | Free tier | ~24 full courses, no card | Very limited; most content paywalled | | Catalog shape | 73+ courses, 4 paths | One opinionated linear backend path (~23 courses, 8 projects) | | Time to complete primary path | 11-108 hrs depending on path | ~12 months for most beginners | | AI engineering | 12 courses (agents, RAG, MCP, Vercel AI SDK) | Minimal | | Algorithms / CS theory | One 2.5-hr DSA course (Pro) | Strong (Big-O, trees, graphs, linked lists) | | Gamification | None | XP, streaks, achievements, RPG framing | | Community | Discord (basic free, Pro-only channels) | Discord | [Visit Boot.dev](https://www.boot.dev/) ## Curriculum comparison: backend Scrimba [Backend Developer Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/) (~39 hours): Node.js, Express, SQL, TypeScript, basic cybersecurity, DevOps fundamentals. Assumes JavaScript going in. The Node, Express and SQL courses inside it are free in full (Tom Chant's Node course builds a REST API with no framework; the SQL course is three modules and 62 challenges on a classic-car dealership's database, with a Runner pane in place of a browser preview), so you can sample the backend half before paying. Optimized for someone who already did the [Frontend Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) and now wants Node APIs to ship fullstack work. Boot.dev Backend Developer Path (~12 months at typical pace): Python and C for fundamentals, then Go for production backends, SQL, HTTP, Docker, plus a real CS fundamentals layer (algorithms, data structures, recursion). Closer in scope to the practical half of a CS degree [(Boot.dev Curriculum)](https://github.com/bootdotdev/curriculum). For a JavaScript fullstack role, Scrimba's combined Frontend plus Backend paths get you to a deployable portfolio faster. For a backend-only role at a Python or Go shop, Boot.dev is the stronger primary resource by a wide margin. ## Curriculum comparison: frontend and AI Scrimba has the deepest frontend catalog of any subscription platform: React, Vue, Next.js, TypeScript, CSS, animations, and a 12-course AI engineering track that covers the 2026 LLM tooling layer (agents, RAG, MCP, Vercel AI SDK). Boot.dev has effectively nothing here. If your goal is frontend or AI app work, Boot.dev is the wrong primary subscription. ## Choose Scrimba vs Boot.dev Choose Scrimba if you want frontend, fullstack, or AI engineering, you want to try before you pay, and you learn better by editing the teacher's code inside the video. Start with the [free interactive demo scrim](https://scrimba.com/s0v687325e?via=u42d4986), then move to [Scrimba Pro](https://scrimba.com/our-pricing?via=u42d4986) when you commit to the Frontend, Fullstack, or AI Engineer path. Choose Boot.dev if you want backend-with-CS-fundamentals using Python and Go, you respond well to gamified daily practice, and you want one opinionated linear path rather than a course library. Use both if you are gunning for a fullstack role at a Python-or-Go shop. Run Scrimba's [Fullstack Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) for the frontend half and Boot.dev for the backend and algorithms layer. ## Bottom line These platforms are not direct competitors. They sell different careers. Pick the role you want first, then pick the platform. If you do not know which role you want, Scrimba's free tier is the cheapest way to find out, because Boot.dev's free tier will not get you far enough to know if you like backend work. ## Start with Scrimba's free tier Around 24 free courses including React and JavaScript, no credit card needed. Upgrade to Pro when you are ready for career paths. [Try Scrimba free](https://scrimba.com/?via=u42d4986) ## Related Pages - [Scrimba Backend Developer Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/), what Scrimba's own backend track covers - [Scrimba vs freeCodeCamp](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-freecodecamp/), the free backend-capable alternative - [Scrimba vs The Odin Project](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-odin-project/), another free fullstack-capable resource - [Scrimba vs Codecademy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-codecademy/), broader language coverage - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) | [How Scrims Work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/) **Q: Is Scrimba better than Boot.dev?** It depends on your target role. Scrimba is better for frontend, fullstack, and AI engineering. Boot.dev is better for backend with CS fundamentals. **Q: Does Scrimba have a free tier unlike Boot.dev?** Yes. Scrimba offers around 24 full free courses, no card needed. Boot.dev's free tier is minimal. **Q: How much does Boot.dev cost in 2026?** Around $49 per month or $349 per year. **Q: Can I use Scrimba for backend development?** Yes, the Backend Path covers Node.js, Express, SQL, and TypeScript. For Python or Go backends with algorithms, Boot.dev goes deeper. **Q: Does Boot.dev cover frontend or AI?** Frontend coverage is minimal and AI engineering is not a primary focus. If those are your goals, Boot.dev is not the right primary subscription in 2026. ### Related Guides - [All Comparisons](https://scrimbaguide.tech/docs/comparisons/) - [Fullstack Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) - [Scrimba vs Codecademy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-codecademy/) --- # Scrimba vs Codecademy Source: https://scrimbaguide.tech/docs/comparisons/scrimba-vs-codecademy/ Scrimba is built around one feature, the scrim: pause the instructor's screencast and edit their code in the same window. Codecademy is built around a three-panel browser IDE (instructions, code, output) and a much wider language catalog. Learning web development or AI engineering and you prefer being shown things? Scrimba's format does something Codecademy's does not. Learning Java, C++, Go, or anything else Scrimba doesn't cover? Scrimba isn't on the shortlist. ## Which one fits how you learn? ### 1. Are you learning web/AI, or one of the other 14 languages Codecademy covers? This decides everything else. Scrimba's catalog is JavaScript and TypeScript with Python as a second-tier option. Their four career paths assume web development and AI engineering. [Codecademy covers 14+ languages](https://www.bitdegree.org/online-learning-platforms/codecademy-review) including Java, C++, Go, Ruby, R, SQL, and a substantial data-science track. If your goal is anything not on Scrimba, this article ends here for you and Codecademy is the correct platform. ### 2. Do you learn by watching, or by reading? Scrimba's lessons are video first. Bob Ziroll, Per Borgen, Kevin Powell, and Tom Chant talk you through concepts, type code in front of you, and break things on purpose so you watch them fix them. When a challenge comes, the brief is written as numbered comments in the file, the recording pauses, and you type into the same editor before pressing play to see their solution. Every scrim also has a timestamped transcript panel, so you can skim ahead the way you would in a text lesson. Codecademy lessons are text first. Instructions sit in a left-hand panel, your editor in the middle, the output on the right. You read, you type, you submit. The exercises are interactive but text-driven, [without video instruction by default](https://hackr.io/blog/codecademy-review). This is the largest preference difference and the one most learners get wrong. If you spend twenty minutes on a passive YouTube tutorial and forget half of it, Scrimba's format probably suits you better because the pause-and-edit loop forces engagement. If you find video tutorials slow and want to skim ahead, Codecademy lets you do that and Scrimba's player will feel sluggish in comparison. ### 3. How structured do you need your path to be? Scrimba sells four pre-built career paths: Frontend (about 82 hours), Fullstack (about 108 hours), Backend (about 39 hours), and AI Engineer (about 11 hours). Each path is curated by the platform and ends with portfolio projects and a job-search module. Codecademy publishes more career paths but they are broader in topic (Data Scientist, Back-End Engineer, Front-End Engineer, Cybersecurity, Game Development). Coverage is wider, depth is lower per topic. If you want one ordered track that ends with a hireable portfolio in web dev or AI, Scrimba is set up for that. If you are sampling several careers before committing, Codecademy's catalog gives you more to sample. ## The Verdict Scrimba for web/AI. Codecademy for everything else. Scrimba wins decisively for web development and AI engineering because the in-video coding loop builds the muscle memory text exercises cannot, and the four career paths are well-curated. Codecademy wins for anything outside Scrimba's narrow stack, and for learners who prefer reading to watching. Both have generous free tiers; test the format on the free side before paying either company. ### Pros - Scrimba: Pause-and-edit format keeps you actively coding throughout the lesson - Scrimba: Strong web/AI curriculum with named, identifiable instructors - Codecademy: 14+ languages including Java, C++, Go, R - Codecademy: Mobile app is genuinely usable for review ### Cons - Scrimba: JavaScript-centric, no help if you need Java/C++/Go/mobile - Codecademy: Trustpilot 2.7/5 over ~1,500 reviews, common complaints around aggressive billing and unwanted renewals - Codecademy: Free tier locks more advanced material than Scrimba's does - Both: Neither replaces the experience of building projects from scratch [Try a scrim in your browser](https://scrimba.com/s0v687325e?via=u42d4986) ## Catalog and format, side by side | Feature | Scrimba | Codecademy | | --- | --- | --- | | Teaching format | Video scrims that pause at each challenge; you type in the same editor, with a transcript panel for skimming | Text instructions plus inline editor | | Languages covered | JS, TypeScript, Python, plus HTML and CSS | 14+ including Java, C++, Go, R, SQL | | Catalog size | 73+ focused courses | 300+ shorter modules | | Free-tier scope | ~24 full courses including Learn React (15.1 hrs; only its two Solo Projects are Pro) | Limited intros, most advanced content gated | | Career paths | 4 paths (11 to 108 hrs) | 10+ paths across many fields | | Web/AI depth | Deep, primary focus | Moderate, one track among many | | Mobile experience | Desktop-focused | Mobile app available | | Community | Discord (basic free, Pro-only channels with mentor presence) | Forums plus paid Pro features | | Trustpilot average | ~4.2/5 (77 reviews, September 2026) | 2.7/5 across ~1,500 reviews | [Visit Codecademy](https://www.codecademy.com/) Codecademy sits at 2.7/5 on Trustpilot across roughly 1,500 reviews. Scrimba sits around 4.2/5, from 77 reviews as of September 2026. Third-party reviews name two recurring complaints on Codecademy: aggressive billing and unwanted auto-renewals, plus course material that feels outdated in the more popular tracks. Mitigation: the moment your trial or first month begins, set a calendar reminder 48 hours before the auto-renewal date and cancel from billing settings if the format is not working for you. That single step neutralises the most common refund dispute on the platform. ## React specifically: Bob Ziroll vs Codecademy's text format React is the topic learners most often switch platforms over. Scrimba's flagship React course is [Learn React by Bob Ziroll](https://scrimbaguide.tech/docs/courses/react/learn-react/): 358 lessons, 15.1 hours, free in full apart from two Solo Projects, built with input from Mozilla MDN. It runs six projects: a ReactFacts page, a Travel Journal, Chef Claude (a recipe app that calls the Claude API), a Meme Generator, and two capstones, Tenzies and Assembly: Endgame. One caveat from inside the course: the Chef Claude project pins a July 2024 React 19 release candidate (the capstones run 18.3), and that section needs your own API key plus, per Bob's own update scrim, an SDK upgrade. A representative third-party review of Ziroll's [Advanced React](https://scrimbaguide.tech/docs/courses/react/advanced-react/) course on Medium describes the pacing as "just right" and the explanations as "easy to understand" ([Hassan Tanveer on Medium](https://medium.com/@hassan.tanveer0097/review-advanced-react-by-bob-ziroll-c86e09e20614)). The same review highlights what is genuinely different about Scrimba: "almost as if you and the instructor are pair programming together." Codecademy's React course is text-with-editor in their three-panel IDE, roughly 13 hours on the catalogue, with the early lessons free and the rest gated behind Plus or Pro. The exercises are fill-in-the-blank or write-this-component style. There is no instructor voice. For learners who want to understand why a hook works the way it does, Scrimba's narrated approach (15.1 hours, 358 lessons, Bob Ziroll, free in full) lands better, and when Bob's explanation does not land, the EXPLAIN button in the scrim header builds a narrated video from the code in front of you ([Scrimba Explain](https://scrimbaguide.tech/docs/how-it-works/scrimba-explain/), 10 free for life). For learners who already know JavaScript well and just want syntax reps, Codecademy's format is faster. ## A low-risk sequence if you want to use both If you cannot commit to one, run them in this order and spend nothing until the format proves itself: - Start on Scrimba Free for one week. Open [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) with Bob Ziroll or [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) with Per Borgen. Both are free in full; only the Solo Projects carry a PRO label. No card needed. - If the pause-and-edit loop clicks, upgrade to Pro and take the [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) as your spine. - If you also need a language Scrimba does not cover (Java, C++, Go, R, SQL deep dives), add Codecademy Plus for that one track only, and set a 48-hour pre-renewal calendar reminder the day you subscribe. This sequence keeps your worst case at zero dollars and one cancellation reminder. ## Pricing, briefly Scrimba publishes free, Pro monthly, and Pro annual tiers. Annual is the better per-month rate. Live pricing is [on Scrimba's pricing page](https://scrimba.com/our-pricing?via=u42d4986); regional discounts apply automatically based on country. The [Scrimba pricing breakdown](https://scrimbaguide.tech/docs/pricing/) on this site walks through the structure without quoting numbers that drift. Codecademy publishes Free, Plus (formerly Basic), and Pro tiers. Pricing is in a similar ballpark to Scrimba month-on-month. The [Codecademy 2026 review at BitDegree](https://www.bitdegree.org/online-learning-platforms/codecademy-review) has a current breakdown. Both are subscriptions, not bootcamps. Compare them against other subscriptions, not five-figure career programs. ## Where Codecademy clearly wins Three scenarios where Codecademy is the right answer: - You want to learn a language Scrimba does not cover. Java, C++, Go, Ruby, R, the SQL deep dives, the data-science track. Scrimba does not have these and Pro does not get you closer to them. - You strongly prefer reading to watching. Some learners find video tutorials slow regardless of pause controls. If that is you, Scrimba's format is a tax, not a feature. - You want a mobile app for spaced review. Codecademy's mobile app is decent. Scrimba is desktop-only in practice. ## Where Scrimba clearly wins Four scenarios where Scrimba is the right answer: - You are learning React, JavaScript, TypeScript, or modern AI engineering. The instructors are good, the curriculum is current, the scrim format suits these topics. - You learn best by watching someone code and immediately trying to reproduce it. This is what the pause-and-edit loop is for. - You want one curated path from beginner to portfolio. The [Frontend Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) is the strongest career track Scrimba ships; the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) is the smallest but most current. - You have been getting through Codecademy lessons without retaining anything. Several Reddit and forum threads converge on the same observation: the text-then-type loop on Codecademy is easy to skim past without learning. Scrimba's format makes that harder. ## Bottom line Pick on two things: what you're learning and how you learn. Web development or AI plus watch-and-edit means Scrimba, and the free tier is wide enough to verify that before spending. Anything else, or you prefer reading, means Codecademy. The single best thing you can do before deciding is open a real scrim and a Codecademy lesson side-by-side for ten minutes each. The format difference is felt, not described. ## Related on this site - [Scrimba vs Udemy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-udemy/) - [Scrimba vs freeCodeCamp](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-freecodecamp/) - [Scrimba vs The Odin Project](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-odin-project/) - [Scrimba pricing](https://scrimbaguide.tech/docs/pricing/) and [learning paths](https://scrimbaguide.tech/docs/paths/) - [How scrims work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/) **Q: Is Scrimba better than Codecademy?** For web development and AI engineering, Scrimba's interactive video format and curated career paths make it the stronger choice. Codecademy is better if you need to learn a language Scrimba does not cover (Java, C++, Go, R) or if you strongly prefer reading to watching. **Q: Which is cheaper?** Both publish similar pricing tiers. Scrimba's free tier includes about 24 full courses; Codecademy's free content is mostly intros. **Q: Can I use both?** Yes. Scrimba for web/AI, Codecademy for language-specific topics Scrimba does not cover. **Q: Why does Codecademy have a low Trustpilot rating?** Third-party reviews flag two recurring complaints: aggressive billing including unwanted auto-renewals, and some course material that feels outdated in the more popular tracks. The platform itself works; the practical advice is to cancel before auto-renewal if you do not want to continue. ## Try the pause-and-edit format before paying either platform Open a real scrim in your browser. If the loop clicks, Scrimba Pro unlocks the four career paths with our partner link. [Claim 20% off Scrimba Pro](https://scrimba.com/our-pricing?via=u42d4986) ### Related Guides - [Scrimba Review](https://scrimbaguide.tech/blog/scrimba-review/) - [Best Free Courses](https://scrimbaguide.tech/blog/best-free-scrimba-courses/) - [Frontend Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) --- # Scrimba vs Coursera Source: https://scrimbaguide.tech/docs/comparisons/scrimba-vs-coursera/ Coursera sells credentials: Google, Meta and IBM certificates, plus accredited degrees from real universities. Scrimba sells reps: you edit the instructor's code inside every lesson and ship a portfolio. Startups and product teams weight the portfolio more. Regulated industries, visa paperwork and HR filters still want the credential. Pick based on which one you need next. Coursera Plus runs around $59 per month or $399 per year [(Coursera Plus page)](https://www.coursera.org/courseraplus). Scrimba Pro sits in the same range annually, with a much larger free tier on top. ## Decide in one minute This guide assumes a web dev or AI engineering goal. Want a data science master's or a business analytics degree instead? Coursera wins by default and you can stop here. ## The Verdict Depends on what you are buying Coursera gives you a credential that names a university or Big Tech sponsor. Scrimba gives you a portfolio that names projects. Hiring managers at tech companies in 2026 weight the second more than the first; in regulated industries (healthcare, finance, government) or visa-track roles where a formal credential is part of the paperwork, the first matters more. If you are buying a credential to clear an HR filter, sponsor a visa, or stack ACE-recommended college credit, Coursera wins. If you are buying daily coding reps to ship a portfolio in 90 days, Scrimba's scrim format wins. Most self-taught web developers do better starting with Scrimba and adding a targeted Coursera professional certificate only when a specific job posting demands it. ### Pros - Scrimba: You type inside the lesson, not after the lecture - Scrimba: Around 24 full free courses, no card needed - Scrimba: Focused on web dev and AI engineering, no filler - Coursera: University and Big Tech branding on certificates - Coursera: Accredited bachelor's and master's degrees ### Cons - Coursera: Coding assignments often feel like quizzes rather than projects - Coursera: Catalog is overwhelming if you only want web dev - Scrimba: Certificates do not carry university branding [Try Scrimba free](https://scrimba.com/s0v687325e?via=u42d4986) ## The three decisions that matter ### 1. Accredited credential vs skills you can demo on a call Coursera's flagship offering in 2026 is the Google Career Certificates suite, which has an Employer Consortium of 150+ U.S. companies including Deloitte, Target, Verizon, and Google itself [(Coursera Blog, Google certificates)](https://blog.coursera.org/connecting-google-certificates-and-university-specializations/). ACE recommends up to 15 college credits for the Google certificates, and roughly 2,000 U.S. universities will at least consider that recommendation. Scrimba certificates do not have that institutional weight. What they show is sequence completion: the Frontend, Fullstack, Backend, or AI Engineer path with the projects attached. For most junior web dev roles in 2026, hiring managers still ask for a GitHub link and a portfolio walkthrough. The certificate is a tiebreaker, not the offer. Coursera signals "this person finished a structured program a recognized institution put their name on." Scrimba signals "this person built and shipped these specific projects." At a venture-backed startup or product team, the second signal wins almost every time. At a bank, hospital network, government contractor, or a visa application that asks for documented training, the first signal carries weight the second cannot. If you are pivoting from a non-tech role and need something formal on a CV before you have a portfolio, Coursera helps. If you already have a portfolio in progress, Scrimba's reps are worth more than another credential. ### 2. University-led video vs platform-led scrims Coursera's courses are produced by university faculty and Big Tech teams. The format is recorded lecture, reading, auto-graded quiz, occasional Jupyter notebook or peer-reviewed project. It reads academic because most of the instructors are academics. Scrimba is platform-led: full-time instructors (Bob Ziroll on React, Per Borgen on the frontend basics, Tom Chant on backend) build courses inside the scrim player. You pause the video, edit the instructor's code, see the result, and resume. Challenges arrive as comments in the file with the recording paused. There is no separate IDE to launch, and the quizzes that exist ([Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/)'s "Pop quiz" and "useEffect quiz!") are short retrieval checks, not graded gates. If you have ever finished a Coursera course and realized you never wrote any code without the instructions visible, the scrim format is the fix. If you learn better from a lecture-then-test loop, Coursera's structure feels more like school, which some learners need. ### 3. Breadth (data science, ML, business) vs web-and-AI focus Coursera Plus claims 10,000+ courses spanning data science, machine learning research, business analytics, social sciences, healthcare, and design [(Coursera Plus page)](https://www.coursera.org/courseraplus). If your interests are broad or you are not sure whether you want to be a frontend dev, a data analyst, or a product manager, the breadth is genuine value. Scrimba's catalog is roughly 73+ courses, all coding, almost all web dev and AI engineering. There is no marketing course, no Excel course, no introduction to philosophy. Every hour you spend on Scrimba goes into the JavaScript and Python stack, not optional sidetracks. If you have already chosen "I want to be a frontend developer," Coursera's breadth becomes noise. If you are still mapping the field, Coursera helps you sample. ## Where Coursera clearly wins - Accredited online degrees. Bachelor's and master's programs from accredited universities, with proper transcripts and credit transfer. Scrimba has none of this. - DeepLearning.AI specializations. Andrew Ng's ML and deep learning content remains the standard reference for theoretical ML, and it lives on Coursera. - Non-coding professional certificates. Google Data Analytics, Google UX Design, IBM Cybersecurity Analyst, Meta Marketing Analytics, and similar tracks are credible and have employer consortium support [(Coursera Blog, Google certificates)](https://blog.coursera.org/connecting-google-certificates-and-university-specializations/). - Audit mode. You can audit most individual Coursera courses for free without the certificate, useful for sampling before paying. - Corporate L&D recognition. Big employers know what Coursera is. Many smaller bootcamp-grade platforms are still unknown to non-technical HR teams, though Scrimba does sell its own [team plan for company upskilling](https://scrimbaguide.tech/blog/scrimba-for-teams/) if that is what you are evaluating. ## When Scrimba clearly wins - You want to build and ship a React or Next.js portfolio in the next 90 days. - You are targeting AI engineering work specifically (agents, RAG, MCP, Vercel AI SDK). Coursera has solid theoretical AI content but limited applied stack practice for the 2026 LLM tooling layer. Scrimba's [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) has you store `AI_URL`, `AI_KEY` and `AI_MODEL` as environment variables in the editor and make live calls to a real provider from the first request scrim, on your own key. - You learn better when you can pause the teacher mid-sentence and rewrite their code. - You are juggling a day job and need short, focused sessions rather than university-paced courses with weekly deadlines. - You want a meaningful free tier (around 24 full courses) before committing any money. | Feature | Scrimba | Coursera | | --- | --- | --- | | Teaching format | Interactive scrims (pause and edit code in the player) | Video lectures, readings, auto-graded quizzes, Jupyter notebooks | | Monthly price | Check current pricing | ~$59/mo or ~$399/yr (Coursera Plus) | | Free tier | ~24 full courses, no card | Audit most courses for free (no certificate) | | Certificates | Course and path certificates (Pro) | Google, Meta, IBM, university professional certificates | | Degree programs | No | Yes, accredited bachelor's and master's | | Catalog focus | 73+, all coding (web + AI) | 10,000+ courses across all subjects | | Coding interactivity | Recording pauses at each challenge; you type in the same editor, with a transcript panel per scrim | Separate environments (Jupyter, in-browser IDE) | | AI engineering | 12 courses (agents, RAG, MCP, Vercel AI SDK) | DeepLearning.AI, Google, IBM (theory-heavy) | | College credit | No | ACE-recommended on Google certificates | | Community | Discord (basic free, Pro-only channels) | Course-specific forums | [Visit Coursera](https://www.coursera.org/) ## Scrimba is also on Coursera Scrimba publishes around 11 specializations on Coursera's platform, so you can reach some Scrimba content through a Coursera Plus subscription. The catch: the full interactive scrim, where you edit the instructor's code in the player, only runs on Scrimba's own platform. The Coursera versions are closer to standard video courses. If you already have Coursera Plus for other reasons, sample Scrimba's content there first, then move to scrimba.com if the format clicks. ## Choose Scrimba vs Coursera Choose Scrimba if your goal is a web dev or AI engineering job, you want to code inside lessons, and you would rather build a portfolio than pass quizzes. The free tier alone gives you enough to know whether the format works for you. Start with the [free interactive demo scrim](https://scrimba.com/s0v687325e?via=u42d4986), then upgrade to [Scrimba Pro](https://scrimba.com/our-pricing?via=u42d4986) when you want the four career paths and the certificate. Choose Coursera if you need an accredited degree, want a Google or Meta brand name on your LinkedIn, are exploring non-coding fields, or want ACE college credit. The audit option also lets you sample most courses without paying [(Coursera Plus page)](https://www.coursera.org/courseraplus). ## Bottom line Neither platform is universally better. They sell different things. Coursera sells credentials and breadth; Scrimba sells reps and focus. Know which one you need over the next three months and the choice is straightforward. Most self-taught web developers get further faster on Scrimba, then add Coursera selectively when a specific job or credit goal demands it. ## Related Pages - [Scrimba vs Codecademy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-codecademy/) | [Scrimba vs Udemy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-udemy/) - [Scrimba vs Boot.dev](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-boot-dev/) | [Scrimba vs Treehouse](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-treehouse/) - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) | [Scrimba Review 2026](https://scrimbaguide.tech/blog/scrimba-review/) - [How Scrims Work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/) - [How Scrimba Helps You Escape Tutorial Hell](https://scrimbaguide.tech/docs/how-it-works/tutorial-hell/) **Q: Is Scrimba on Coursera?** Yes. Scrimba publishes around 11 specializations on Coursera. The full interactive scrim experience is only available on Scrimba's own platform. **Q: Is a Coursera certificate worth more than a Scrimba certificate?** For HR filters at large corporations, yes. For developer hiring, your portfolio matters more than either certificate. **Q: How much does Coursera Plus cost in 2026?** Around $59 per month or $399 per year. Audit option is free for most individual courses. **Q: Can I learn React on Coursera?** Yes, through Meta's Front-End Developer Professional Certificate. Scrimba offers more interactive React practice. **Q: Which platform is better for AI in 2026?** Coursera wins for ML theory (Andrew Ng's DeepLearning.AI specializations). Scrimba wins for applied AI engineering on the 2026 LLM tooling stack (agents, RAG, MCP, Vercel AI SDK). ## Practice in scrims, audit on Coursera Try Scrimba's ~24 free courses to see if the format clicks. Use Coursera when you specifically need the credential. [Try Scrimba free](https://scrimba.com/?via=u42d4986) ### Related Guides - [Scrimba for CS Students](https://scrimbaguide.tech/docs/for/cs-students/) - [Certificates Guide](https://scrimbaguide.tech/blog/complete-guide-scrimba-certificates/) - [Scrimba Student Discount](https://scrimbaguide.tech/docs/pricing/student-discount/) --- # Scrimba vs Educative Source: https://scrimbaguide.tech/docs/comparisons/scrimba-vs-educative/ Educative teaches through text with an embedded code playground; Scrimba teaches through video with an editable code panel inside it. Educative wins for coding-interview and system-design prep, led by its Grokking series. Scrimba wins for building a web or AI portfolio from scratch, with about 24 courses free, no card required. Pick by the format you retain. Reviewed inside Scrimba with a Pro account, September 2026. ## Video with an editor vs text with a playground Scrimba is video with an editor inside it. Educative is text with a playground next to it. Neither is the inferior format. Pick by which one feels less exhausting at the end of a working day, and by which one you remember the next morning. ## The Verdict Pick by medium: video learners go Scrimba, text learners go Educative Scrimba wins for learners who retain more from a guiding voice and a screencast they can pause and edit. The paths produce a real project portfolio for web and AI roles. Educative wins for learners who read faster than they watch, and for anyone grinding interview prep. The Grokking series for coding interviews and system design is the industry default, and the text-plus-embedded-playground format is a genuine alternative to video, not a downgrade from it. ### Pros - Scrimba: code inside the instructor's video (active practice) - Scrimba: project portfolio output from career paths - Scrimba: about 24 full courses free, no card required - Educative: 1,600+ courses, text-first with embedded playgrounds - Educative: Grokking the Coding Interview and Grokking System Design - Educative: faster to skim once you're past beginner stage ### Cons - Scrimba: one 2.5-hour DSA course; no system design - Scrimba: no LeetCode-pattern style interview prep - Educative: text-heavy can feel dry; no instructor voice - Educative: higher annual pricing than most video subscriptions [Try a scrim in your browser](https://scrimba.com/s0v687325e?via=u42d4986) | Feature | Scrimba | Educative | | --- | --- | --- | | Teaching format | Interactive video scrims (pause & edit code) | Text articles with embedded code playgrounds | | Pricing model | Monthly or annual | $200/yr list, often discounted to ~$80-$100/yr | | Free tier | ~24 full courses, no card | 7-day trial plus some free lessons | | Catalog size | 73+ focused courses | 1,600+ courses and learning paths | | Interview prep | JavaScript Interview Challenges (Pro, 28 challenges, 2.3 hrs) plus a 2.5-hr DSA course | Industry-leading Grokking series | | System design | Not covered | Grokking System Design (204 lessons, 13+ designs) | | AI/ML coverage | 12 engineering courses (agents, RAG, MCP) | ML interview and applied ML courses | | In-browser coding | Yes, inside the video | Yes, embedded playgrounds | | Community | Discord (basic free, Pro-only channels) | Large developer audience, lighter community features | | Learning speed | Video paced | Read at your own pace (faster) | | Best for | Building web and AI apps from scratch | Interview prep, system design, applied CS | | Output | Project portfolio (React apps, AI agents) | Pattern fluency and design vocabulary | [Visit Educative](https://www.educative.io/) ## Text-with-runnable-code vs video-with-editable-code This is the only format difference that matters. Both platforms let you run code in the browser. The question is what wraps that code. Scrimba wraps it in video. You hear Bob Ziroll or another instructor explain a concept, you see their cursor, you pause and edit the same code they were just typing. That voice and that pause-and-try beat are what makes the scrim format effective for someone who's never built a component before. Readers are not shut out either: every scrim has a timestamped transcript panel under the settings menu, and on [Learn SQL](https://scrimbaguide.tech/docs/courses/backend/sql/) it was accurate enough to follow the whole course from it. And when the instructor's explanation is not enough, the EXPLAIN button in the lesson header hands the same code to [Scrimba Explain](https://scrimbaguide.tech/docs/how-it-works/scrimba-explain/) for a second, narrated take. Educative wraps it in text. You read an article-style explanation, look at the diagram, then run the playground next to it. Once you're past the absolute-beginner phase, this is faster: you can skim, jump to the bit you need, and skip the ums and pauses of a video. For dense topics like distributed systems or hash-table internals, text plus a diagram beats a 20-minute talking head. ## Interview prep vs career path Educative built its reputation on the Grokking series. Grokking the Coding Interview Patterns teaches the dozen-or-so problem patterns (sliding window, two pointers, modified binary search) that cover most LeetCode questions. Grokking the System Design Interview includes 204 lessons and 13+ real-world designs, updated through 2026. Grokking the Machine Learning Interview is the same model for ML roles. If your bottleneck is passing a FAANG-style interview, these are the industry default. Scrimba's output is different. The [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) (81.6 hours) ends with a portfolio of React apps. The [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) ends with working agents and RAG systems. The artifact is a GitHub portfolio plus a path certificate, not a pattern fluency. Its interview material is a Pro drill pack, [JavaScript Interview Challenges](https://scrimbaguide.tech/docs/courses/javascript/javascript-interview-challenges/) (28 problems from FizzBuzz to an emoji slot machine, Treasure Porth), and a 2.5-hour [Data Structures and Algorithms](https://scrimbaguide.tech/docs/courses/javascript/data-structures-and-algorithms/) course with Vitest test files per challenge. Neither is a patterns curriculum. For breaking into junior frontend or AI engineering roles where a take-home project matters more than a whiteboard, this is the right output. ## Depth of specific topics vs breadth Educative's 1,600+ courses cover more topics than Scrimba's catalog. If you want a deep dive into Kubernetes internals, a Rust beginner course, or an applied NLP track, Educative probably has it. Scrimba is deliberately narrow: JavaScript, React, TypeScript, HTML/CSS, Python, SQL, plus the AI engineering track. The depth on those topics is high (around 10 React courses and 30 JavaScript courses), but if you want a course on Rust or Erlang, you're on the wrong site. ## Where Educative wins outright - Coding interview prep: Grokking the Coding Interview Patterns is the highest-leverage purchase for someone with a FAANG loop coming up. - System design: Grokking the System Design Interview is the default starting point for mid-to-senior backend interview prep. - ML interview prep: Grokking the Machine Learning Interview fills a gap most video platforms don't touch. - Reading speed: Once you're not a beginner, you'll finish topics faster in text than in video. ## Where Scrimba wins outright - Zero-to-hireable on web/AI: Scrim format is gentler for someone who's never written a function before. - Project portfolio: The paths ship with capstone projects that go straight to a GitHub README. - AI engineering depth: 12 courses on agents, RAG, MCP, and the Vercel AI SDK. Educative covers ML interview prep, not modern AI app shipping. - Free tier: About 24 full courses, including [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) and [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/), no card required. - Day-to-day cost for individuals: Scrimba's personal pricing is typically lighter than Educative's list price. ## Use both if You're a self-taught dev who finished Scrimba's [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/), built a portfolio, landed a junior role, and now you have a senior interview loop in six months. Use Scrimba for the day-job skills, switch to Educative's Grokking series for the interview cycle. The two platforms are complementary across a career, not competitors in a given month. ## Bottom line Choose by the next ninety days of your life. If those days are "I've never written a React component and I want a junior role," Scrimba. If those days are "I have a system design interview at a Series B startup," Educative. Both platforms are good at what they do; neither is good at the other's job. ## Related Pages - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) | [Scrimba vs Codecademy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-codecademy/) - [Scrimba vs Frontend Masters](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-frontendmasters/) | [Scrimba vs Coursera](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-coursera/) - [JavaScript Interview Challenges](https://scrimbaguide.tech/docs/courses/javascript/javascript-interview-challenges/) | [All Comparisons](https://scrimbaguide.tech/docs/comparisons/) - [All Scrimba Courses](https://scrimbaguide.tech/docs/courses/) | [Scrimba Review 2026](https://scrimbaguide.tech/blog/scrimba-review/) ## Sources - [Grokking the Coding Interview Patterns (Educative)](https://www.educative.io/courses/grokking-coding-interview) - [Grokking the System Design Interview (Educative)](https://www.educative.io/courses/grokking-the-system-design-interview) - [Grokking the Machine Learning Interview (Educative)](https://www.educative.io/courses/grokking-the-machine-learning-interview) - [Educative.io review (CourseFacts, 2026)](https://www.coursefacts.com/guides/educative-io-review-2026) - [Educative Unlimited Plan review (Javarevisited, 2026)](https://javarevisited.wordpress.com/2026/03/17/review-is-educative-unlimited-plan-really-worth-it-in-2026/) **Q: Is Scrimba better than Educative for beginners?** Yes. Scrimba's video-with-editable-code format is easier for a first-time learner to follow. Educative's text-with-playground approach is faster once you already type comfortably. **Q: Which is better for coding interview prep?** Educative. The Grokking the Coding Interview Patterns and Grokking the System Design Interview courses are industry defaults. **Q: Which has better interactive coding?** Both let you code in the browser. Scrimba embeds the editor inside the instructor's video; Educative embeds playgrounds inside text articles. Scrimba feels more guided; Educative more self-directed. **Q: Is Educative worth the annual price?** If interview prep is your primary use case, yes. For learning web or AI from scratch, Scrimba is the better-value primary platform. ## Scrimba Pro for the day-job skills; Educative when interviews loom Pro covers React, JavaScript, TypeScript, and the AI engineering catalog. Add Educative's Grokking series when the interview loop is on the calendar. Use our partner link to get 20% off the Pro plan. [Claim 20% off Scrimba Pro](https://scrimba.com/our-pricing?via=u42d4986) ### Related Guides - [All Comparisons](https://scrimbaguide.tech/docs/comparisons/) - [Fullstack Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) - [Scrimba vs Codecademy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-codecademy/) --- # Scrimba vs Fireship Source: https://scrimbaguide.tech/docs/comparisons/scrimba-vs-fireship/ Quick answer: Fireship is one instructor, Jeff Delaney, making ultra-fast YouTube explainers ("X in 100 seconds") plus a smaller catalog of paid Pro courses. Scrimba is a curated platform with multiple specialist instructors, an editor built into every lesson, and full career paths. Pick Fireship for a mental model in two minutes. Pick Scrimba to build a skill over weeks. Most working developers end up using both. ## Different time horizons Scrimba builds skill over weeks. Fireship gives you a mental model in 100 seconds. They aren't competing for the same five minutes of your day. ## The Verdict Curated platform vs charismatic instructor Scrimba is the better learning platform if you want structured paths, multiple specialist instructors, and the editor inside every lesson. The format takes a beginner from zero to a portfolio of projects. Fireship is the better pick if you'd rather have one charismatic instructor than a curated catalog. Jeff Delaney's short-form videos and Pro courses are excellent for working developers who need to size up a new tool in 10 minutes, not 10 hours. ### Pros - Scrimba: structured paths from beginner to hireable - Scrimba: code inside the lesson, no IDE setup - Scrimba: multiple specialist instructors per topic - Fireship: signature humor and pacing make complex topics stick - Fireship: huge free YouTube catalog (millions of subscribers) - Fireship: lifetime Pro plan available ### Cons - Scrimba: not a lookup tool for 'what is X in 60 seconds' (Scrimba Explain comes closest, 10 explainers free for life) - Fireship: assumes you already code; bad for absolute beginners - Fireship: one-person catalog limits topic breadth and pace - Fireship: no embedded code editor; you code along locally [Try a scrim in your browser](https://scrimba.com/s0v687325e?via=u42d4986) | Feature | Scrimba | Fireship | | --- | --- | --- | | Teaching format | Video scrims that pause at each challenge; you type in the same editor | Fast-paced video courses; code along locally | | Free content | ~24 full courses, no card | Huge YouTube catalog (millions of subscribers) | | Pricing model | Monthly or annual subscription | Quarterly subscription or lifetime plan | | Catalog size | 73+ focused courses | ~20 paid Pro courses + free YouTube library | | Career paths | 4 structured paths (up to 108 hrs) | No structured paths | | Instructors | Multiple specialists per topic | Jeff Delaney (single-creator brand) | | Content depth | Multi-hour, project-driven | Concise overviews and project Pro courses | | Voice/style | Patient, instructor-led | Dense, fast, opinionated, signature humor | | AI engineering | 12 courses (agents, RAG, MCP) | Frequent AI-related YouTube coverage | | Best for | Going from zero to hireable | Quick tech awareness for working devs | | Certificates | Course and path certificates (Pro) | Not offered | | Community | Discord (basic free, Pro-only channels) | Private Discord (Pro) | [Visit Fireship](https://fireship.io/) ## Short-burst lookups vs structured learning A Fireship video is engineered for 30 to 120 seconds of insight. "React in 100 Seconds." "Next.js in 100 seconds." "What is MCP?" You finish the video with a vocabulary and a mental model, not a working app. That's the point. When you're already a working dev and a new framework appears in your team's Slack, Fireship gets you to "I know what people are talking about" faster than anything else. Scrimba is engineered for the opposite problem: going from no skill to a real one. The [Learn React course](https://scrimbaguide.tech/docs/courses/react/learn-react/) is 15.1 hours and 358 lessons across six projects (a ReactFacts page, a Travel Journal, Chef Claude, a Meme Generator, Tenzies, Assembly: Endgame), with 170+ challenges where the recording stops until you type. The [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) takes weeks. Nobody hires a developer because they watched a 100-second video. If you're brand new, Fireship will leave you with a head full of names and no ability to build. If you're already mid-level, Scrimba's pace may feel slow when you just need the gist. ## Signature humor vs straight teaching Jeff Delaney's voice is the product. The cuts, the deadpan jokes, the opinionated takes ("this framework will solve all your problems… for about six months") are why Fireship outdraws platforms 100x its size on YouTube. The downside: if the style doesn't click for you, no other instructor steps in. It's one creator. Scrimba splits topics across multiple specialists. Bob Ziroll teaches React, other instructors teach AI engineering, Python, TypeScript. The voices are different, the pace is patient, and the format leaves room for you to type, not just to laugh. Less personality, more practice. ## One-instructor brand vs multi-instructor catalog Fireship.io is a tightly curated catalog around what Jeff wants to teach. Roughly 20 Pro courses, frequently on bleeding-edge topics (Next.js full-stack apps, Astro, Supabase, modern AI tooling). The strength is taste and timeliness; the weakness is breadth and depth on any single topic. Scrimba runs more like a learning platform: dozens of courses across React, JavaScript, TypeScript, Python, SQL, HTML/CSS, plus a 12-course AI engineering track. If you want three different teachers' takes on hooks, you can find them. ## Where Fireship wins outright - Free YouTube catalog: Hundreds of free videos, no signup. For "what is X?" questions, nothing is faster. The nearest Scrimba equivalent is [Scrimba Explain](https://scrimbaguide.tech/docs/how-it-works/scrimba-explain/), a narrated slide video built from a typed question, capped at 10 on a free account. - Pacing for working devs: A Fireship Pro course gets to the build faster than most platforms get past the intro. - Lifetime plan: A one-time payment option exists for Pro, which appeals to people who hate recurring subscriptions. - Voice and taste: Jeff's editorial sense surfaces tools you might not have noticed. The platform has cultural relevance most learning platforms don't. ## Where Scrimba wins outright - Beginner pathway: A non-coder can start the [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) on Monday and feel productive by Wednesday. - Code in the lesson: Fireship expects you to code along in your local editor. Scrimba removes that friction, and each scrim has a "Download as Zip" for when you do want the project locally. - Project portfolio: Career paths end with capstone apps. Fireship's Pro courses include projects but no portfolio framing. - Free tier with full courses: About 24 complete courses are free, including [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) and [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/). Fireship's free tier is YouTube videos, not full Pro courses. - Certificates and structured progression: Useful for LinkedIn and for self-pacing across a quarter. ## Use both, almost always Watch the Fireship YouTube video before you start a Scrimba course on the same topic. The 100-second version gives you the map; the Scrimba course gives you the legs. Once you're employed, keep Fireship in your feed for trend awareness. Keep Scrimba (or move on) for skill deepening. ## Bottom line Scrimba and Fireship serve different brains on different days. If you're learning to code, Scrimba is the platform; Fireship is the YouTube channel you put on at lunch. If you're already shipping code, Fireship may give you more bang per minute than any subscription you have, and you can stop paying for the structured platforms entirely. ## Related Pages - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) | [Scrimba vs YouTube](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-youtube/) - [Scrimba vs Udemy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-udemy/) | [Scrimba vs Frontend Masters](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-frontendmasters/) - [Frontend Developer Path Review](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) | [All Comparisons](https://scrimbaguide.tech/docs/comparisons/) - [How Scrims Work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/) - [All Scrimba Courses](https://scrimbaguide.tech/docs/courses/) | [Scrimba Review 2026](https://scrimbaguide.tech/blog/scrimba-review/) ## Sources - [Fireship YouTube channel](https://www.youtube.com/c/Fireship) - [Fireship.dev site](https://fireship.dev/) - [Jeff Delaney podcast interview (CodingCat.dev)](https://codingcat.dev/podcast/0-9-jeff-delaney-of-fireship-io) - [Fireship customer reviews (Trustpilot)](https://www.trustpilot.com/review/fireship.io) - [Fireship channel profile (Wikitubia)](https://youtube.fandom.com/wiki/Fireship) **Q: Is Scrimba better than Fireship for learning to code?** For beginners, yes. Scrimba offers structured paths and interactive practice. Fireship assumes you already code and moves much faster. **Q: Can I use both Scrimba and Fireship?** Yes. Watch Fireship's YouTube for quick mental models and trend awareness. Use Scrimba for structured skill-building. They complement each other. **Q: Is Fireship Pro lifetime worth it?** Good value if you like Jeff Delaney's pacing and want to avoid recurring subscriptions. Not a substitute for a structured beginner platform like Scrimba. **Q: Who is Jeff Delaney?** The creator behind Fireship. He runs the YouTube channel and produces the Pro courses on fireship.dev. It's a one-creator brand. ## Scrimba Pro for the long-form path; Fireship YouTube for the gist Pro covers the structured React, JavaScript, and AI engineering paths. Keep Fireship in your feed for the 100-second versions when a new tool ships. Use our partner link to get 20% off the Pro plan. [Claim 20% off Scrimba Pro](https://scrimba.com/our-pricing?via=u42d4986) ### Related Guides - [All Comparisons](https://scrimbaguide.tech/docs/comparisons/) - [Frontend Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) - [Scrimba vs YouTube](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-youtube/) --- # Scrimba vs freeCodeCamp Source: https://scrimbaguide.tech/docs/comparisons/scrimba-vs-freecodecamp/ freeCodeCamp is a free, project-gated nonprofit curriculum with 11 certifications; Scrimba is a Norwegian startup selling a paid interactive-video platform where you pause the instructor mid-sentence and edit the code they just typed. Pick freeCodeCamp if budget is the constraint or you want blank-editor practice graded by automated tests. Pick Scrimba if a narrated walkthrough teaches you faster than reading a spec, especially for React and AI. It comes down to three decisions about how you study. ## The three decisions that matter 1. Paid-but-interactive, or entirely free. Scrimba Pro is a real subscription (see [scrimba.com/our-pricing](https://scrimba.com/our-pricing?via=u42d4986) for the current rate). freeCodeCamp is donation-funded. If budget is the gate, start with freeCodeCamp. 2. Project-driven, or lesson-driven. Each freeCodeCamp certification ends with 5 required projects you build from a blank editor, gated on passing automated tests ([certifications overview](https://www.freecodecamp.org/news/freecodecamp-certifications/)). Scrimba builds projects inside lessons (Learn React's Tenzies and Assembly: Endgame are walked through scrim by scrim), which is gentler. Its blank-canvas test is the Solo Projects: a design file and a written spec with no walkthrough, and those are Pro. 3. How much weight you put on the certificate. That is the argument learners have most often, covered below. ## The Verdict It depends on budget and study style freeCodeCamp wins on cost (truly $0), breadth (11 certifications including data analysis, info security, and ML), and project-by-doing rigor. Scrimba wins when reading text drills exhausts you faster than the lessons teach you, and when you want a human voice walking through React, AI, or modern JS while you type. ### Pros - freeCodeCamp: 100% free, 11 certifications, project-gated - freeCodeCamp: huge community (forum, Discord, study groups) - Scrimba: pause-and-edit video makes React click for visual learners - Scrimba: focused web dev and AI curriculum, less to wade through ### Cons - freeCodeCamp: no live instructor voice on most tracks - freeCodeCamp: certifications carry limited weight with employers (see below) - Scrimba: Pro subscription required to unlock career paths [Try a Scrimba scrim (no signup)](https://scrimba.com/s0v687325e?via=u42d4986) | Feature | Scrimba | freeCodeCamp | | --- | --- | --- | | Cost | Free tier + Pro subscription | 100% free, donation-funded nonprofit | | Teaching format | Interactive video scrims (pause and edit) | Text lessons + browser test runner | | Instructor voice | Yes (Bob Ziroll, Per Borgen, others) | Text-first; separate YouTube channel for video | | Certifications | 4 career path certificates | 11 certifications, ~300 hrs each, 5 projects each | | Project rigor | Guided builds in lessons; Solo Projects (spec plus design file, no walkthrough) are Pro | Build from blank editor; tests must pass | | Topics | React, JS, TS, Python, AI, cybersecurity | Web, Python, data analysis, info security, ML | | Community | Discord (basic free, Pro-only channels) | Forum, Discord, local study groups, 10M+ YouTube subs | | Best for | Visual learners on React and AI | Self-starters comfortable reading specs | [Visit freeCodeCamp](https://www.freecodecamp.org/learn) ## What freeCodeCamp covers freeCodeCamp is a 501(c)(3) nonprofit Quincy Larson founded in 2014, and the entire curriculum runs on donations ([Wikipedia](https://en.wikipedia.org/wiki/FreeCodeCamp)). The curriculum is 11 certifications, each roughly 300 hours, each requiring 5 projects ([freeCodeCamp certifications](https://www.freecodecamp.org/news/freecodecamp-certifications/)): Responsive Web Design, JavaScript Algorithms and Data Structures (a new v9 launched December 2025 with a sit-down exam, [news post](https://www.freecodecamp.org/news/freecodecamps-new-javascript-certification-is-now-live/)), Front End Development Libraries (React, Redux, Sass), Data Visualization (D3), Relational Databases, Back End and APIs (Node, Express, MongoDB), Quality Assurance, Scientific Computing with Python, Data Analysis with Python, Information Security, and Machine Learning with Python. Scrimba does not cover this surface area. No D3, no info security cert, no ML certification. If those are what you need, freeCodeCamp is the only one of the two in the conversation. ## The certification debate This is the recurring argument on Reddit, HN, and the freeCodeCamp forum. Do hiring managers care about a freeCodeCamp certificate? Short answer: not much, but they care about what you built to earn it. A 2025 hackr.io review puts it plainly: "the certificate will not likely get you a job or impress an employer ... the portfolio projects will be more valuable than its certificates" ([hackr.io review](https://hackr.io/blog/freecodecamp-review)). The DEV.to thread "Is a freeCodeCamp Certificate Worth It?" lands in roughly the same place: the certification proves you sat through the work; the 5 finished projects prove you can ship ([DEV.to](https://dev.to/stack_overflowed/is-a-freecodecamp-certificate-worth-it-3l6b)). The freeCodeCamp forum's own advice on resume listings is pragmatic: lead with the projects and treat the cert as a footnote ([freeCodeCamp forum](https://forum.freecodecamp.org/t/listing-freecodecamp-certifications-in-resume/249984)). The newer Full Stack Developer path drew the same mixed reception on Hacker News in late 2024 ([HN discussion](https://news.ycombinator.com/item?id=42541541)). What carries freeCodeCamp graduates into jobs is the project portfolio and public GitHub history, not the cert. Scrimba's career path certificates sit in the same spot. Neither is a credential the way a degree or AWS exam is. The "no instructor voice on most tracks" point is the trade you are making with freeCodeCamp: you give up hand-holding and a narrated debugging walkthrough in exchange for cost-free credentialing and the kind of blank-editor practice employers notice. Whether that trade is worth it depends on whether you stall when you cannot see someone else stuck on the same bug. If you do, the Scrimba free tier covers the same React surface area with a human voice at zero cost. ## Curriculum comparison: React This is the one place where format makes a sharp difference. freeCodeCamp's React track lives inside Front End Development Libraries. Read instructions, write code, pass tests. The 5 capstones (Random Quote Machine, Markdown Previewer, Drum Machine, Calculator, Pomodoro Clock) are blank-editor builds with no instructor. If you finish, you have shipped 5 React apps from scratch. Scrimba's [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) (15.1 hours, free) is Bob Ziroll on video, built with Mozilla MDN. The recording pauses 170+ times for a challenge written as comments in the file, and you type into the same editor. Gentler on first-timers because the abstractions (state, effects) get a human voice while you type. The projects are a ReactFacts page, a Travel Journal, Chef Claude, a Meme Generator, and two capstones, Tenzies and Assembly: Endgame. Bob's line on those last two: "Do not under any circumstances skip these capstone projects." If "ship 5 React apps with nothing but tests guiding you" sounds energizing, freeCodeCamp. If "I need someone to explain why useEffect ran twice" sounds like you, Scrimba, and that question can also go to the EXPLAIN button in the lesson, where [Scrimba Explain](https://scrimbaguide.tech/docs/how-it-works/scrimba-explain/) answers it as a short video. ## Two different theories of learning Quincy Larson runs the freeCodeCamp Podcast, which restarted in 2023 and now publishes weekly ([podcast playlist](https://www.youtube.com/playlist?list=PLWKjhJtqVAbm04DK8TSUCRheRjW2P9TR7)). The recurring theme across his interviews is consistency over cleverness: show up, build the project, publish it, repeat for a year. The platform does not try to make you feel fast; it tries to make you finish. Scrimba optimizes for the opposite: reducing friction between "I see the concept" and "I have typed the concept." Both legitimate, different shapes. ## Using both, low-risk sequence Most learners run them in parallel. This order keeps your spend at zero until the paid format has proved itself: - Start freeCodeCamp Responsive Web Design. Free, project-gated, no decisions to make. - When you hit JavaScript Algorithms and Data Structures and want a human voice, open Scrimba's free [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) with Per Borgen alongside it (9.4 hours, 140+ challenges, free in full). Still no card needed. - Try Scrimba's free [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) (15.1 hours, 358 lessons, free in full; only the two Solo Projects carry a PRO label) before deciding whether to pay for anything. - Only upgrade to Scrimba Pro if step 3 clicks and you want the Frontend or AI Engineer career path on top. ## Bottom line freeCodeCamp wins on cost and breadth: it's free, and 11 certifications cover ground Scrimba never touches, from data visualization to machine learning. Scrimba wins on format: pause-and-edit video with a real instructor teaches React and AI faster than reading a spec, and the free tier (Learn JavaScript, Learn React) costs nothing to try first. If you stall without someone narrating the bug you're stuck on, start with Scrimba's free courses. If you want project-gated credentials and don't need the hand-holding, freeCodeCamp is the only one of the two built for that. ## Related pages - [Scrimba pricing](https://scrimbaguide.tech/docs/pricing/) | [Best free Scrimba courses](https://scrimbaguide.tech/blog/best-free-scrimba-courses/) - [Scrimba vs The Odin Project](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-odin-project/) (the other free option worth weighing) - [Scrimba vs Codecademy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-codecademy/) | [Scrimba vs Udemy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-udemy/) - [Scrimba vs YouTube](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-youtube/) - [How scrims work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/) **Q: Is Scrimba better than freeCodeCamp?** Neither is universally better. freeCodeCamp wins on cost and breadth. Scrimba wins when text drills exhaust you and you want a human voice walking through React or AI while you type. **Q: Do employers take freeCodeCamp certifications seriously?** Mostly the projects, not the certificate. The 5 required projects per certification and your public portfolio do the persuading; the certification is supporting evidence. **Q: Does Scrimba have free courses like freeCodeCamp?** Yes, about 24 free courses including Learn React, Learn JavaScript, and Learn TypeScript. Pro unlocks career paths and the rest of the 49+ course catalog. **Q: Which has better React content?** Different shape. freeCodeCamp makes you ship 5 React projects from a blank editor with no instructor. Scrimba's Learn React (15.1 hrs, free) is video-led with Bob Ziroll where you pause and edit inline. Pick the one that matches how you study. **Q: Can I use both Scrimba and freeCodeCamp?** Yes, and most learners we hear from do. A common pattern is freeCodeCamp for structured certifications and Scrimba's free courses for any topic where the text-first format is slowing you down. ## Once Scrimba Free has clicked, Pro unlocks the career paths Use our partner link for 20% off the Pro plan. Cancel from billing settings at any time. [Claim 20% off Scrimba Pro](https://scrimba.com/our-pricing?via=u42d4986) ### Related Guides - [Best Free Courses](https://scrimbaguide.tech/blog/best-free-scrimba-courses/) - [Is Scrimba Free? Pro vs Free](https://scrimbaguide.tech/docs/pricing/pro-vs-free/) - [Scrimba for Beginners](https://scrimbaguide.tech/docs/for/beginners/) --- # Scrimba vs Frontend Masters Source: https://scrimbaguide.tech/docs/comparisons/scrimba-vs-frontendmasters/ Frontend Masters is a premium workshop library: senior engineers like Brian Holt, Will Sentance, and Sarah Drasner record six-to-eight-hour deep dives for a live class, and you rebuild the project afterward in your own editor. Scrimba puts you inside the lesson instead: pause, edit the instructor's code, run it, resume. Beginners start on Scrimba; working developers add Frontend Masters for senior depth. ## Decide in one minute Three questions cover most of it. - Beginner-friendly format vs intermediate-to-expert workshops. Scrimba paths walk a beginner from "what is a variable" to a deployable React app. Frontend Masters assumes you already know the syntax and teaches you how the framework works under the hood. - In-lesson coding vs watch-and-rebuild. Scrimba lets you pause a scrim and edit the instructor's file in place. Frontend Masters records live workshops; you watch the instructor type, then rebuild it in your own editor. - Structured paths vs deep workshops. Scrimba ships four career paths (Frontend, Fullstack, Backend, AI Engineer) with a fixed order. Frontend Masters offers curated learning paths, but the unit of value is the standalone workshop, not the path. ## The Verdict Different stages, different price tiers Scrimba is the better starting point for beginners and early intermediates: in-lesson coding, four ordered career paths, named React and AI instructors. Frontend Masters is the better second subscription once you ship apps and want senior-level depth on TypeScript, performance, system design, or React internals. On price, Frontend Masters lists $39/month or $390/year (their published rates); in most regions that puts FM at roughly 2x Scrimba's annual rate per month at list. Confirm Scrimba's current number on scrimba.com/our-pricing. Many developers run Scrimba first, then add Frontend Masters. ### Pros - Scrimba: Code inside the lesson (pause, edit, run, resume) - Scrimba: Structured career paths and dedicated AI engineering track - Scrimba: Trustpilot 4.2/5 (77 reviews); named instructors Bob Ziroll, Per Borgen, Kevin Powell, Tom Chant - Frontend Masters: Senior instructors with industry name recognition (Holt, Sentance, Drasner, Kinney, Firtman) - Frontend Masters: Deep 6-to-8-hour workshops on advanced topics, live workshop attendance ### Cons - Frontend Masters: Watch-only video; assumes you can rebuild in your IDE - Frontend Masters: $39/month or $390/year at list, roughly 2x Scrimba's annual rate per month in most regions - Frontend Masters: Assumes prior JavaScript knowledge; not built for absolute beginners - Scrimba: Lighter on expert-level content (Advanced React's performance module is 109 minutes; no system design) - Scrimba: No live workshops [Try a Scrimba scrim, no signup](https://scrimba.com/s0v687325e?via=u42d4986) | Feature | Scrimba | Frontend Masters | | --- | --- | --- | | Teaching format | Scrims: recording pauses at each challenge, you type in the same editor | Recorded live workshops, ~6-8 hours each | | Target audience | Beginner to intermediate | Intermediate to senior developers | | Interactivity | Pause and edit inside the lesson | Watch the workshop, code along in your own IDE | | Career paths | 4 structured paths (Frontend, Fullstack, Backend, AI) | Curated learning paths (workshop lists) | | Instructor pool | Small specialist team (Bob Ziroll, Per Borgen, others) | Brian Holt, Will Sentance, Steve Kinney, Sarah Drasner, Maximiliano Firtman | | Topics | Web dev, AI engineering, Python, cybersecurity | Advanced JS, TypeScript, React internals, performance, system design, DevOps | | Monthly price | See our pricing page | $39/month | | Annual price | See our pricing page | $390/year | | Free tier | ~24 full courses | Preview lessons only | | AI courses | 12 dedicated AI courses (agents, RAG, MCP) | Some AI workshops, not the focus | | Community | Discord (basic free), Pro-only channels with instructor presence | Limited community features | | Reputation signal | Trustpilot 4.2/5 (77 reviews); freeCodeCamp mirrors the Bob Ziroll React course | Industry name recognition through instructors (Holt, Sentance, Drasner, Kinney) | [Visit Frontend Masters](https://frontendmasters.com/) ## What does a Frontend Masters course look like? A Frontend Masters course is a recording of a live workshop. The instructor stands in front of a room of paying attendees, teaches for two days, and the camera captures the whole thing, including the in-room questions. There is no in-video editing in the Scrimba sense; you watch the screen share, take notes, and rebuild the project in your own editor afterward. The catalog is built around senior names. Brian Holt runs the "Complete Intro to React" track and a product management workshop; Will Sentance teaches the JavaScript hard parts series rooted in Codesmith's classroom approach; Steve Kinney covers state, performance, and now AWS for front-end engineers; Sarah Drasner has the SVG and animation deep dives; Maximiliano Firtman handles mobile web and PWA territory. That format is the whole pitch: you pay $39 a month to watch a workshop you would otherwise need to fly to and pay four figures to attend in person. ## Where Frontend Masters clearly wins - Expert depth. If you want a six-hour TypeScript workshop or a deep dive on React rendering internals, Frontend Masters has more of that than Scrimba does. - Recognized instructors. Brian Holt, Sarah Drasner, and Will Sentance carry real industry brand. Hiring managers know the names. - Breadth of senior content. Performance, accessibility, web security, system design, Node internals, browser APIs. The catalog leans toward the kind of topics a mid-level engineer studies for a staff interview. - Live workshops. Subscribers can attend new workshops live and ask questions, which Scrimba does not currently offer. ## Where Scrimba wins - Beginner pacing. Scrimba assumes nothing. [Learn HTML and CSS](https://scrimbaguide.tech/docs/courses/css/html-and-css/) opens with tags and a "Write a news article!" challenge, has you editing BBC headlines in DevTools in its first module, and deploys a one-page personal site inside the first 75 minutes. [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) ends with Tenzies and Assembly: Endgame. Frontend Masters' "Complete Intro" courses are explicitly intermediate; the platform itself recommends prior JavaScript experience. - In-lesson coding. This is the single biggest format difference. On Scrimba you pause Bob Ziroll mid-sentence, edit his file, run the result, then resume. Challenges arrive as numbered comments in the file with the recording paused, and every scrim carries a timestamped transcript. Frontend Masters cannot do that, because the source is a live workshop recording. - Structured career paths. Scrimba's Frontend, Fullstack, Backend, and AI Engineer paths give you a fixed order with checkpoints and certificates. Frontend Masters offers curated lists, but the work of sequencing still falls on you. - A free tier that teaches, not just previews. About 24 Scrimba courses are free in full, including [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/). Frontend Masters preview clips do not get you to a working project. - AI engineering coverage. Scrimba has 12 dedicated AI courses covering agents, RAG, MCP, and prompt engineering. Frontend Masters has a handful of AI workshops, but that is not the platform's center of gravity. ## What do Scrimba and Frontend Masters cost? Frontend Masters lists $39 per month or $390 per year for individual access on [their join page](https://frontendmasters.com/join/), with team plans at $24.50 per seat per month for groups of ten or more. The annual plan saves about 17%. GitHub Student Developer Pack members get six months free. Scrimba prices vary by region and run promotions year-round, so I link to [scrimba.com/our-pricing](https://scrimba.com/our-pricing?via=u42d4986) instead of quoting a number that will be wrong by the time you read this. Here is the anchor: Frontend Masters' $39/month list price is roughly 2x what Scrimba's annual plan works out to per month in most regions, and FM's $390/year sits well above Scrimba's annual at list. Scrimba's free tier is also larger: about 24 full courses (including the 15-hour [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) with Bob Ziroll) versus preview clips on Frontend Masters. Frontend Masters is priced like a senior workshop library. Scrimba is priced like a structured beginner-to-intermediate platform, and that gap shows up in the per-month math. ## When to choose Scrimba - You are a beginner or early-intermediate developer who has not yet shipped a real app - You learn better when you type along inside the lesson instead of switching to a separate editor - You want a fixed sequence (paths) instead of picking workshops off a menu - You are aiming at AI engineering ([AI Engineer path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/)) or cybersecurity ([Learn Cybersecurity](https://scrimbaguide.tech/docs/courses/javascript/cybersecurity/)) - You want a Discord community of other learners ## When to choose Frontend Masters - You already ship apps for a living and want to level up to senior or staff - You want deep dives on TypeScript, performance, React internals, system design, or accessibility - You learn fine from a workshop recording and prefer rebuilding the project in your own editor - You value named instructors (Brian Holt, Will Sentance, Sarah Drasner) and live workshop attendance - $39 a month is a small line item against your salary ## Bottom line These are not competitors so much as stages. Scrimba walks a beginner to "I can build and deploy a React app." Frontend Masters takes a working developer and pushes them toward "I understand how this framework works under the hood." Starting out, go with Scrimba first. Already have a job and want to grow into a harder one? Frontend Masters is worth $39 a month. Plenty of developers end up subscribing to both, just at different points in their career. ## Related Pages - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) | [Scrimba vs Codecademy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-codecademy/) - [Scrimba vs The Odin Project](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-odin-project/) | [Scrimba vs Coursera](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-coursera/) - [Scrimba vs YouTube](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-youtube/) interactive coding vs passive video - [How Scrims Work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/) the technology that sets Scrimba apart - [All Scrimba Courses](https://scrimbaguide.tech/docs/courses/) | [Learning Paths](https://scrimbaguide.tech/docs/paths/) ## Sources - [Frontend Masters pricing (Join page)](https://frontendmasters.com/join/) - [Frontend Masters Brian Holt teacher page](https://frontendmasters.com/teachers/brian-holt/) - [Frontend Masters live workshops](https://frontendmasters.com/workshops/) - [Frontend Masters course catalog](https://frontendmasters.com/courses/) - [Scrimba official pricing](https://scrimba.com/our-pricing?via=u42d4986) **Q: Is Scrimba better than Frontend Masters for beginners?** Yes. Scrimba is built for beginners and early intermediates with in-lesson coding and structured paths. Frontend Masters targets developers who already ship apps. **Q: How much does Frontend Masters cost in 2026?** $39 per month or $390 per year for individual access, per the official join page. Team plans start at $24.50 per seat per month. **Q: Can I use both Scrimba and Frontend Masters?** Yes. Scrimba for structured beginner-to-intermediate paths, then Frontend Masters for senior-level workshops once you are shipping apps. **Q: Does Frontend Masters have interactive coding?** No. It is workshop-recording video. Scrimba is the platform with in-lesson code editing. **Q: Who teaches on Frontend Masters?** Senior engineers and authors including Brian Holt (Microsoft), Will Sentance (Codesmith), Steve Kinney (Temporal), Sarah Drasner, and Maximiliano Firtman, among others. ## Start on Scrimba, add Frontend Masters when you are ready About 24 Scrimba courses are free in full, and Pro runs at roughly half FM's $39 monthly rate in most regions. Confirm at scrimba.com/our-pricing. Use our partner link to get 20% off the Pro plan. [Claim 20% off Scrimba Pro](https://scrimba.com/our-pricing?via=u42d4986) ### Related Guides - [All Comparisons](https://scrimbaguide.tech/docs/comparisons/) - [Frontend Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) - [Scrimba vs Udemy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-udemy/) --- # Scrimba vs The Odin Project Source: https://scrimbaguide.tech/docs/comparisons/scrimba-vs-odin-project/ The Odin Project is a free, open-source curriculum: reading, links, and a project brief, then you set up a real dev environment and build it yourself. Scrimba is a paid platform, with a wide free tier, built around the scrim, a video you pause and edit the instructor's code in. Odin wins on cost and real-environment practice; Scrimba wins on speed and instructor guidance. ## Three decisions that settle it ### 1. Paid-interactive or free-open-source? Odin is free forever, with no Pro tier and no upsell. The whole [Foundations course plus the Full Stack JavaScript or Ruby on Rails track](https://www.theodinproject.com/paths) costs nothing. Scrimba publishes a free tier (about 24 full courses, including Bob Ziroll's fifteen-hour [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/)) and a Pro subscription that unlocks the four career paths, the Solo Projects, certificates, unlimited challenges, and the Pro-only Discord channels. Live numbers are on [scrimba.com/our-pricing](https://scrimba.com/our-pricing?via=u42d4986); the pricing breakdown on this site walks through the structure in [Scrimba pricing](https://scrimbaguide.tech/docs/pricing/). If budget is the binding constraint and you have the discipline to self-pace, Odin wins on this axis cleanly. If you have a few dollars a month and want the format to do some of the discipline work for you, Scrimba's pause-and-edit loop is what you are paying for. ### 2. Video-led, or text-and-build-it-yourself? This is the format question and it decides most of the rest. Scrimba's lessons are screencasts where named instructors (Bob Ziroll, Per Borgen, Kevin Powell, Tom Chant) narrate their thinking, type code in front of you, then hand the editor over so you can change it and run it. When something breaks, you watch them debug it in real time; Per writes bugs on purpose in [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) and reads the error aloud before fixing it. Odin's lessons are reading. Each step is a curated set of MDN pages, freeCodeCamp articles, blog posts, and sometimes a YouTube link, followed by an assignment that says, in effect, "now go build this on your own." There is no instructor narration. There is no in-browser editor. You install Node, set up Git, configure your terminal, and write code in VS Code like a working developer would. That difference is not cosmetic. Odin teaches you to read documentation, which is the actual job. Scrimba teaches you the concepts faster but lets you stay in a sandboxed browser longer than is good for you. It does point the way out: [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) has a four-scrim local-setup module (GitHub Desktop, VS Code, a push to GitHub) and deploys the first project to Netlify, and [Learn HTML and CSS](https://scrimbaguide.tech/docs/courses/css/html-and-css/) sends you into DevTools on the BBC site and publishes with GitHub Desktop. It just never makes you do it. ### 3. Curated path, or full autonomy? Scrimba sells four pre-built career paths: Frontend (about 82 hours), Fullstack (about 108 hours), Backend (about 39 hours), AI Engineer (about 11 hours). Each one is ordered, ends with portfolio projects, and includes a getting-hired module. You do not decide what comes next; the platform decided. Odin has [two tracks past Foundations](https://www.theodinproject.com/paths), Full Stack JavaScript (7 courses) and Full Stack Ruby on Rails (8 courses). The order is fixed but the autonomy inside each lesson is total. You pick which linked article to read first, you decide when a project is "done," and you debug your own environment problems because nobody is going to do it for you. For self-starters, that autonomy is the whole point. For learners who freeze when given an open-ended brief, it is the failure mode. ## The Verdict Odin is free but high-friction. Scrimba is paid but low-friction. The Odin Project's price tag is $0, but the real cost is friction: installing Node, configuring Git, debugging your own environment, and pushing through reading-heavy lessons with no instructor voice. For self-directed learners that friction is the feature (it is what working developers do all day). For learners who freeze when an npm install fails at 11pm with no one to ask, the same friction is the failure mode. Scrimba pays the friction tax for you with an in-browser editor and named instructors, and charges money for the career paths and AI track. Many learners use both: Odin for project rigor, Scrimba for React or AI depth. ### Pros - Odin: Truly free, no upsell, full curriculum unlocked from day one - Odin: Forces real-environment setup (Node, Git, VS Code) which is what employers expect - Odin: Portfolio projects are large enough to show in interviews - Scrimba: Pause-and-edit format removes the day-one setup wall - Scrimba: Named instructors narrating tricky concepts (React hooks, async, AI engineering) ### Cons - Odin: Free price, high friction. Steep curve, sink-or-swim, environment problems are yours to solve - Odin: No video instruction (links to external videos, but no original screencasts) - Odin: No mentors. Help is peer-to-peer on an open Discord; survivors answer survivors - Scrimba: Costs money for the career paths and AI engineer track - Scrimba: In-browser editor can delay the real-environment skills Odin forces on day one [Try a Scrimba scrim, no signup](https://scrimba.com/s0v687325e?via=u42d4986) ## Catalog and format, side by side | Feature | Scrimba | The Odin Project | | --- | --- | --- | | Teaching format | Interactive video scrims (pause, edit, run) | Curated reading + projects from scratch | | Price | Free tier + Pro subscription | 100% free, no paid tier | | Free courses | ~24 full courses including Learn React (15 hrs) | Entire curriculum is free | | Tracks | 4 career paths (11 to 108 hrs) | Foundations + Full Stack JS (7 courses) or Ruby on Rails (8 courses) | | Video instruction | Yes, instructor-led interactive scrims | No original video, occasional external links | | Dev environment | In-browser editor; optional local-setup module and Netlify deploys in the beginner courses | Local setup from the start (Node, Git, VS Code) | | Projects | Guided builds (Blackjack, a Chrome extension, Tenzies) plus Pro Solo Projects from a design file and spec | Large from-scratch projects throughout | | Languages | JS, TypeScript, Python, HTML/CSS, SQL | JS, Ruby, HTML/CSS, SQL | | AI engineering | 12 courses (agents, RAG, MCP, LangChain) | None | | Community | Discord (basic free), Pro-only channels with instructor presence | Open Discord (~90,000+ members), peer-to-peer | | Certificates | Path certificates (LinkedIn-shareable) | None | | Trustpilot | 4.2/5 (77 reviews) | 3.7/5 | [Visit The Odin Project](https://www.theodinproject.com/) The Trustpilot numbers favor Scrimba here: Scrimba sits at 4.2/5 (77 reviews, September 2026), while Odin's public average is around 3.7/5 ([Trustpilot](https://www.trustpilot.com/review/www.theodinproject.com), as of 2026). Treat both as rough signals, not verdicts: a free, self-directed curriculum draws a different mix of reviewers than a paid platform, and Trustpilot skews toward people motivated enough to post. Both remain widely recommended in their category. ## Where Odin clearly wins Three places where The Odin Project is the right answer: - Cost is binding. Odin is genuinely free, with no Pro tier waiting to upsell you and no "premium content" gated behind a button. If you cannot or will not pay for learning, this is the strongest free curriculum on the web. - You need real-environment skills now, not later. Installing Node, configuring Git, debugging a broken `npm install`, navigating a project in VS Code; Odin makes you do these from week one. Scrimba's in-browser editor is friendlier but it delays this skill, and you will need it for any real job. - You want portfolio projects an employer will look at. Odin's project briefs are large, opinionated, and reviewed by peers. A finished Odin etch-a-sketch, library app, or full-stack capstone is yours, not a guided walkthrough you can show. The official [Odin success stories page](https://www.theodinproject.com/success_stories) collects testimonials from people who got hired off the back of the curriculum. The pattern is consistent: roughly a year of focused work, a handful of solid portfolio projects, a job offer. ## Where Scrimba clearly wins Four places where Scrimba is the right answer: - You learn faster watching someone code. The pause-and-edit loop is the whole point. If you have bounced off text-heavy curricula before, Scrimba's format does something Odin's cannot. - The early curve is breaking you. Odin is famously sink-or-swim in the first few weeks. Scrimba's instructor narration smooths the slope; you can come back to Odin later when the fundamentals are solid. - You want AI engineering content. Scrimba ships 12 AI courses covering agents, RAG, MCP, LangChain, Claude, and the Vercel AI SDK. Odin has none. If your near-term goal is shipping AI features, this is decisive. - You want a curated path that ends in a hireable portfolio. Scrimba's Frontend and Fullstack paths include portfolio modules and a getting-hired module. Odin's projects are stronger individually; Scrimba's container around them is tighter. ## Communities, briefly Both platforms have Discord servers and both matter, but they do different jobs. Odin's Discord is open to anyone, around 90,000 members, and the help is peer-to-peer. There are no formal mentors. You post your code, someone a few steps ahead of you replies. This works because the curriculum is shared and people in the same project can recognise what you are stuck on. The [ComputerScience.org Odin review](https://www.computerscience.org/bootcamps/reviews/odin-project/) notes the same point: no one-on-one mentorship, but a strong learner community. Scrimba's Discord is open to free accounts; the Pro-only channels are the ones that matter. They are smaller, gated to Pro subscribers, and instructors plus Scrimba staff are present in them. If you want a higher signal-to-noise channel and you are paying for Pro anyway, this is meaningfully different from Odin's open server. ## Using both Most learners converge on the same pattern: Odin for foundations and project rigor, Scrimba (free tier) for the React course and any AI engineering you want to add. Scrimba's free tier is wide enough that you can pull the React course alongside Odin's Full Stack JavaScript path at no cost. Upgrading to Pro is worth it once you want the curated path or the AI engineer track. The reverse also works. Some learners start on Scrimba to get past the first-month wall, then switch to Odin for the project-heavy middle of the curriculum where the autonomy is the lesson. Either order is defensible. ## Bottom line Both platforms are good. Pick on budget, discipline, and learning channel. Choose The Odin Project if you have the self-discipline to read documentation and build from scratch, want to learn the way working developers work, and value free over fast. Choose Scrimba if the early curve is breaking you, you want video instruction and modern AI courses, or you want one curated path that ends with a portfolio and a getting-hired module. If you can stomach Odin's pacing, the price is right and the projects are real. If you cannot, Scrimba's free tier alone is enough to learn React without paying anything. The single best thing you can do before committing is open the Odin Foundations first lesson and a Scrimba scrim side-by-side for fifteen minutes each. The format gap is felt, not described. ## Related on this site - [Scrimba vs freeCodeCamp](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-freecodecamp/) - [Scrimba vs Codecademy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-codecademy/) - [Scrimba vs YouTube](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-youtube/) - [Scrimba pricing](https://scrimbaguide.tech/docs/pricing/) and [Pro vs Free](https://scrimbaguide.tech/docs/pricing/pro-vs-free/) - [All comparisons](https://scrimbaguide.tech/docs/comparisons/) - [How scrims work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/) - [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) **Q: Is Scrimba better than The Odin Project?** It depends on learning style and budget. Scrimba is video-interactive and paid; Odin is reading-and-projects and free. Many learners use both. **Q: Is The Odin Project really free?** Yes, the entire curriculum is free with no paid tier. **Q: Can I learn React on The Odin Project?** Yes. Odin's Full Stack JS track covers React. Scrimba's free Learn React course is a common supplement. **Q: Does The Odin Project give certificates?** No. Scrimba does, for completed career paths. **Q: Can I use both?** Yes. Common pattern: Odin for foundations and project rigor, Scrimba free tier for React and AI. **Q: Which platform is better for getting hired?** Both can lead to jobs. Odin's project requirements produce strong portfolios; Scrimba's career paths include a dedicated getting-hired module. Odin's official success stories page collects job-offer testimonials from learners who completed the curriculum. ## Stack Odin's grit with Scrimba's interactive React If Odin's reading-heavy lessons stall you on React, the curated Frontend and AI Engineer paths are the friction-light alternative. Live pricing is at scrimba.com/our-pricing. Use our partner link to get 20% off the Pro plan. [Claim 20% off Scrimba Pro](https://scrimba.com/our-pricing?via=u42d4986) ### Related Guides - [Scrimba for CS Students](https://scrimbaguide.tech/docs/for/cs-students/) - [Fullstack Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) - [Scrimba Review](https://scrimbaguide.tech/blog/scrimba-review/) --- # Scrimba vs Pluralsight Source: https://scrimbaguide.tech/docs/comparisons/scrimba-vs-pluralsight/ Pluralsight is built for company-paid team training: Skill IQ assessments, manager dashboards, and a 6,500+ course catalog across AWS, Azure, and CompTIA. Scrimba is built for one learner on the path to a first web or AI engineering job: scrims you code inside, four focused career paths, and a free tier to try before you pay. Pick Scrimba if you're paying yourself for web or AI skills. Pick Pluralsight if your employer is paying, or you need certification prep. ## The one-sentence framing Scrimba teaches you to build in the browser. Pluralsight measures you, then assigns courses to close gaps across a broad enterprise topic map. ## The Verdict Depends on who's paying and what you're optimizing for Scrimba wins for the individual learning web development or AI engineering from scratch. The scrim format and focused paths beat passive video for retention. Pluralsight wins when your employer is paying, when you need certification prep (AWS, Azure, CompTIA), or when you need to benchmark and close gaps across a broad IT topic map using Skill IQ. ### Pros - Scrimba: code inside the instructor's video (active practice) - Scrimba: focused paths for Frontend, Fullstack, Backend, and AI Engineer - Scrimba: generous free tier, no card required to start - Pluralsight: 6,500+ courses spanning DevOps, security, cloud, and data - Pluralsight: Skill IQ assessments (200+ topics, 0-300 score) - Pluralsight: hands-on labs and sandboxes for AWS, Azure, GCP ### Cons - Scrimba: narrower catalog, light on DevOps, cloud, and cert prep - Scrimba: no skill assessment scoring or org dashboards - Pluralsight: per-seat enterprise pricing, expensive without an employer - Pluralsight: video is mostly passive; labs are separate from lessons [Try a scrim in your browser](https://scrimba.com/s0v687325e?via=u42d4986) | Feature | Scrimba | Pluralsight | | --- | --- | --- | | Teaching format | Interactive video scrims (pause & edit code) | Traditional video + separate labs/sandboxes | | Pricing model | Personal monthly / annual | Per-seat; team plans ~$399-$779/yr; enterprise custom | | Free tier | ~24 full courses, no card | 10-day free trial | | Catalog size | 73+ focused courses | 6,500+ courses across IT | | Skill assessments | Not available | Skill IQ across 200+ topics, 0-300 scoring | | Certification prep | Not available | AWS, Azure, GCP, CompTIA, and others | | Hands-on labs | Every scrim is an editor; challenges pause the recording until you type | Multi-cloud sandboxes (AWS, Azure, GCP) | | AI engineering | 12 courses (agents, RAG, MCP) | AI+ specialty plan | | Career paths | 4 paths (up to 108 hrs) | Role IQ + topic paths | | Community | Discord (basic free, Pro-only channels) | Limited community features | | Target audience | Individual web/AI learners | Enterprise teams, IT pros, cert candidates | | Org analytics | None | Manager dashboards, skill gap reporting | [Visit Pluralsight](https://www.pluralsight.com/) ## Individual learner vs team training If you're paying out of pocket and the goal is a frontend, fullstack, or AI engineering role, Scrimba is the closer match. The scrim format keeps you typing from minute one. The four [career paths](https://scrimbaguide.tech/docs/paths/) (Frontend, Fullstack, Backend, AI Engineer) are short enough to finish in a focused quarter, and the free tier means you can prove the format works for you before paying. Pluralsight is built around a different buyer: a manager who needs to upskill a team of developers, sysadmins, or security engineers across a topic map their org cares about. The per-seat pricing makes sense when work pays. As a personal subscription, it's harder to justify against narrower, hands-on platforms. ## Skill IQ scoring vs project portfolio Pluralsight's Skill IQ is the feature most people associate with the platform. It uses adaptive testing with Bayesian modeling to measure proficiency in any of 200+ technologies. A 10-15 minute assessment gives you a 0-300 score across five proficiency levels (Novice, Beginner, Proficient, Advanced, Expert), and Pluralsight then recommends courses to lift weak spots. For an org, the same data rolls up into manager dashboards showing skill gaps by department. Scrimba has no equivalent. Its currency is the project portfolio. You finish [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) with Tenzies and Assembly: Endgame built scrim by scrim, each with a "Download as Zip" to get the files into your GitHub, and the two Pro Solo Projects (a Digital Business Card and Quizzical) built from a spec with no walkthrough. You finish the [AI Engineer path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) with working agents and RAG systems. This is the right artifact for a hiring manager looking at a junior or career-changer. It's the wrong artifact for an L&D lead trying to certify that 200 employees can pass an AWS exam. ## Web/AI focus vs broad IT stack Scrimba's catalog is deliberately narrow: JavaScript, React, TypeScript, HTML/CSS, Python, SQL, plus a strong 12-course AI engineering track covering agents, RAG, MCP, and the Vercel AI SDK. There is no SCCM, no Active Directory, no Kubernetes Operator pattern course. Pluralsight covers the rest of the IT stack: cloud architecture, security, networking, data engineering, DevOps tooling, mobile, game dev, and IT ops. If your week involves a Terraform pull request and an Azure incident, Pluralsight has the courses; Scrimba doesn't pretend to. ## Where Pluralsight wins outright - Certification prep: AWS Solutions Architect, Azure Administrator, CompTIA Security+, and dozens more have dedicated learning paths with exam-aligned objectives. - Cloud sandboxes: Hands-on labs in real AWS, Azure, and GCP accounts without burning your own bill. - Org analytics: Skill IQ data feeds dashboards that show which teams are weakest on which topics. Useful when reporting up to a VP. - Breadth: 6,500+ courses across far more than web. If you're a working sysadmin who wants to dabble in Go, then Kubernetes, then incident response, the catalog covers it. ## Where Scrimba wins outright - Beginner-to-hireable on web/AI: The interactive format produces results faster than passive video for someone who's never built anything ([Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/)). - AI engineering depth: 12 courses on agents, RAG, MCP, and modern AI tooling. Pluralsight's AI+ track is broader but less hands-on for shipping AI features. - Price for individuals: A personal Scrimba subscription is dramatically cheaper than a personal Pluralsight Premium plan. Verify [current pricing](https://scrimbaguide.tech/docs/pricing/) on each site. - Free tier: About 24 full courses, including [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) and [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/), no card required. ## Use both if You're an employed developer whose company pays for Pluralsight, but your weekend goal is shipping a side project with React and a RAG agent. Use Pluralsight for the work-mandated cert prep, use Scrimba for the side project. The two platforms don't conflict; they target different hours of your week. ## Bottom line Pick by who's paying and what you're optimizing for. Individual learner targeting a web or AI role: start with Scrimba's free tier and decide in a weekend. Employed developer needing cert prep or org-wide upskilling: Pluralsight is built for exactly that. Don't pay personally for Pluralsight to learn React when Scrimba does it better. Don't try to learn AWS Solutions Architect on Scrimba when Pluralsight has the sandbox. ## Related Pages - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) | [Scrimba vs Frontend Masters](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-frontendmasters/) - [Scrimba vs Udemy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-udemy/) | [Scrimba vs Coursera](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-coursera/) - [Frontend Developer Path Review](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) | [All Comparisons](https://scrimbaguide.tech/docs/comparisons/) - [How Scrims Work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/) - [All Scrimba Courses](https://scrimbaguide.tech/docs/courses/) | [Scrimba Review 2026](https://scrimbaguide.tech/blog/scrimba-review/) ## Sources - [Pluralsight Skill IQ assessments](https://www.pluralsight.com/product/skills-assessment) - [Pluralsight individual pricing](https://www.pluralsight.com/individuals/pricing) - [Pluralsight team and business pricing](https://www.pluralsight.com/businesses/pricing) - [Pluralsight Skills review (SaaSWorthy, 2026)](https://www.saasworthy.com/product/pluralsight-skills) - [Pluralsight pricing breakdown (FindBetter, 2026)](https://findbetter.net/education/pluralsight-pricing/) **Q: Is Scrimba better than Pluralsight for web development?** For an individual learning from scratch, yes. Scrimba's scrim format embeds the editor in the lesson and its paths are tuned for hireable web and AI skills. Pluralsight is built for enterprise IT training and certification prep across a much broader stack. **Q: Does Pluralsight have interactive coding like Scrimba?** Premium includes labs and sandboxes, but they're separate from the video. Scrimba embeds the code editor inside the lesson itself. **Q: What is Pluralsight Skill IQ?** An adaptive 10-15 minute assessment that scores you on a 0-300 scale across five proficiency levels in 200+ technologies, then recommends courses to close gaps. Scrimba has no equivalent. **Q: Is Pluralsight worth it without an employer paying?** Usually not for web or AI learners. The per-seat pricing is built for organizations. If you're paying personally for web/AI skills, Scrimba is the better value. ## Scrimba Pro is what an individual web/AI learner actually buys If work pays for Pluralsight, stack Scrimba Pro on top for the web and AI side projects. If nobody's paying for Pluralsight, Scrimba Pro is the better personal subscription. Use our partner link to get 20% off the Pro plan. [Claim 20% off Scrimba Pro](https://scrimba.com/our-pricing?via=u42d4986) ### Related Guides - [All Comparisons](https://scrimbaguide.tech/docs/comparisons/) - [Fullstack Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) - [Scrimba vs Udemy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-udemy/) --- # Scrimba vs Treehouse Source: https://scrimbaguide.tech/docs/comparisons/scrimba-vs-treehouse/ Treehouse is an established video library dating to 2011, plus the Techdegree program, which pairs its courses with human-reviewed capstone projects. Scrimba is newer and narrower: scrims are interactive lessons where you edit the instructor's code inside the video itself. For current web development and AI engineering, Scrimba's in-lesson practice and free tier win. Treehouse still wins for Techdegree-style coached review. ## Decide in one minute Treehouse keeps showing up in older "best place to learn to code" lists. For web dev and AI, Scrimba is the more current platform. For Techdegree-style coached projects, Treehouse still has a niche. ## The Verdict Winner: Scrimba for most 2026 learners Scrimba's scrim format is a generation ahead of Treehouse's video-plus-quiz flow, the free tier is meaningful, and the catalog is current. Treehouse remains a real option only if you want the Techdegree's human project reviews or need older topic coverage Scrimba does not have. ### Pros - Scrimba: You type inside the video, not in a separate workspace - Scrimba: Around 24 free full courses; Treehouse offers only a trial - Scrimba: 2026-current curriculum (React 19, Next.js, MCP, AI engineering) - Treehouse: Polished video production with strong studio quality - Treehouse: Techdegree program includes human-reviewed capstone projects ### Cons - Treehouse: Older platform (launched 2011), curriculum updates slower than peers - Treehouse: Catalog has visibly outdated material outside the Techdegree programs - Treehouse: Techdegree at $199/mo is steep for self-taught learners - Treehouse: Minimal AI engineering coverage in 2026 [Try Scrimba free](https://scrimba.com/s0v687325e?via=u42d4986) ## The three decisions that matter ### 1. Established library vs current curriculum Treehouse launched in 2011 and that history shows on both ends. The polish on the older videos is high; reviewers rate the production quality strongly [(BitDegree Treehouse Review)](https://www.bitdegree.org/online-learning-platforms/treehouse-review). What the marketing pages do not surface is that the platform updates its curriculum more slowly than the rest of the field. Reviews flag inconsistent content currency, courses that still reference older framework versions, and gaps in newer tooling [(BitDegree comparison)](https://www.bitdegree.org/tutorials/codecademy-vs-treehouse). The Techdegree programs (Front End, Full Stack JavaScript, Python, Data Analysis, UX) are the most actively maintained tier; the rest of the library skews older. Scrimba's catalog is smaller (around 73+ courses) but it is current in the corners that matter for 2026 web dev. [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) covers React 19 in a free 69-minute course on the new hooks (its Chef Claude project still pins a July 2024 React 19 release candidate while the capstones run 18.3, so "current" is relative), plus Next.js, TypeScript, modern CSS, and a 12-course AI engineering track covering agents, RAG, MCP, and the Vercel AI SDK. If your goal is "learn what people are hired to write in 2026," current matters more than catalog depth. Treehouse is the stable, slower-moving platform, built for a learner who values structure and production quality over leading-edge stack coverage. ### 2. Video-first vs interactive video Treehouse's format is traditional in shape: a polished instructor video, then a quiz, then a code challenge in a separate workspace. It is interactive in the loose sense that you eventually type code, but the typing is between videos, not during them. Scrimba's scrims put the editor inside the video. The instructor types, you pause, you edit the same code, you resume and watch what they do next. Context switching drops to near zero. This is not a small UI difference; it is a different learning loop. Research on retention, from the testing effect (Roediger and Karpicke, 2006) to the active-learning literature, points the same direction: typing while you watch beats watching and then typing. If you prefer a watch-then-practice rhythm because that matches how you study, Treehouse's format is fine. If you have ever finished a video course and realized you cannot reproduce anything without the tutorial open, the scrim format is the fix. ### 3. Tracks vs paths (and the Techdegree question) Treehouse organizes content into Tracks (themed bundles of courses) and the Techdegree, which is a higher-priced project-based program with human-reviewed capstones. The Techdegree at $199 per month is the headline product for serious career changers [(Treehouse Techdegree)](https://teamtreehouse.com/techdegree). Each Techdegree includes 9-12 units that culminate in projects reviewed by Treehouse staff and other students. Scrimba organizes content into four career paths (Frontend, Fullstack, Backend, AI Engineer). There is no equivalent of the Techdegree's staff code review. Community feedback happens in the Discord (basic access is free, code-review channels are Pro-only) and through community projects, not through a graded rubric. The closest thing to a capstone is the Pro Solo Projects: in [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) each one (a basketball scoreboard, a password generator, a unit converter) comes with a Figma design file, a written spec and stretch goals, but no walkthrough and nobody marks it. Some newer challenges carry a "Challenge with Instant Feedback" marker, where an AI checks your code against the spec. That is automated feedback, not a human review. If you specifically want a human grading your capstone project before you put it on a portfolio, Treehouse's Techdegree is a real differentiator. If you can self-evaluate or get feedback from a Discord community, Scrimba's paths cover the same ground for a fraction of the price. ## Where Treehouse clearly wins - Techdegree project reviews. Human-graded capstones are rare on subscription platforms. If accountability through review matters to you, this is genuine value [(Treehouse Techdegree)](https://teamtreehouse.com/techdegree). - Video production polish. The studio quality is consistently rated higher than most learning platforms [(BitDegree Treehouse Review)](https://www.bitdegree.org/online-learning-platforms/treehouse-review). - Java and C# coverage. Scrimba does not teach these languages at all. If you specifically want Java for an enterprise role or C# for game dev or .NET work, Treehouse has more. - Lower entry-level monthly cost. The Courses plan starts around $25 per month, below Scrimba Pro's monthly rate [(Treehouse Techdegree)](https://teamtreehouse.com/techdegree). The catch is the lack of in-lesson interactivity at that tier. - Established brand recognition. Treehouse has been around since 2011 and is still a recognized name in older bootcamp-prep circles. ## When Scrimba clearly wins - You want React, Next.js, TypeScript, or modern fullstack JavaScript work. - You want AI engineering content that reflects the 2026 LLM tooling stack, not a vague intro to ML from three years ago. - You learn better when the editor is inside the video. - You want a real free tier before paying. Around 24 full free courses vs Treehouse's 7-day trial is not close. - You want current frontend curriculum without sifting through older material. | Feature | Scrimba | Treehouse | | --- | --- | --- | | Teaching format | Interactive scrims (edit code in the video) | Video + quizzes + separate code challenges | | Interactivity | Recording pauses at each challenge; you type in the same editor | Separate practice workspaces between videos | | Career paths | 4 paths (up to 108 hrs) | Tracks plus Techdegree programs | | Topics covered | Web dev, fullstack JS, Python (AI), AI engineering | Web dev, Python, Java, C#, design | | AI engineering | 12 courses (agents, RAG, MCP, Vercel AI SDK) | Minimal | | Free tier | ~24 full courses, no card | 7-day free trial only | | Entry-level monthly price | Check current pricing | ~$25/mo (Courses) after 7-day trial | | Top tier monthly price | Pro (annual is best value) | ~$199/mo (Techdegree) | | Platform age and update cadence | Launched 2017, current with 2026 stack | Launched 2011, slower curriculum refresh | | Project review | Self-assessed Solo Projects; AI-checked challenges in newer courses; Discord (Pro-only code-review channels) | Techdegree includes staff and peer review | | Content currency | Regularly updated (2026 refresh) | Mixed; some courses visibly dated | | Community | Discord (basic free, Pro-only channels) | Slack community | [Visit Treehouse](https://teamtreehouse.com/) ## Pricing reality check Treehouse's entry tier starts around $25 per month after a 7-day trial [(Treehouse pricing)](https://teamtreehouse.com/pricing), and the Techdegree program runs at $199 per month [(Treehouse Techdegree)](https://teamtreehouse.com/techdegree). Treehouse has simplified its plan structure over the years, so the higher-priced "Courses Plus" middle tier from earlier coverage may or may not be listed at the moment; the live pricing page is the only place to verify. The Courses tier is cheap but lacks much of the interactive challenge content; the Techdegree is a different product entirely. Scrimba Pro's annual plan typically lands close to Coursera Plus and below the Techdegree by a wide margin. The free tier of around 24 full courses is the cleanest "try before you buy" option in this comparison. If you want a single-tier price comparison, the Treehouse Courses subscription vs Scrimba Pro is the fair one. The Techdegree is a different product (coached program) and should be compared against entry-level bootcamps, not against a self-paced subscription. ## Choose Scrimba vs Treehouse Choose Scrimba if you want modern web dev or AI engineering, you learn better with the editor inside the video, and you want a real free tier before committing. Start with the [free interactive demo scrim](https://scrimba.com/s0v687325e?via=u42d4986), then move to [Scrimba Pro](https://scrimba.com/our-pricing?via=u42d4986) when you want the four career paths and the path certificate. Choose Treehouse if you want the Techdegree's human-reviewed capstones, you need Java or C# coverage, or you prefer a watch-then-practice rhythm with high-production-quality videos. ## Bottom line Treehouse is not a bad platform; it has just been overtaken on the specific axis (in-lesson interactivity, current frontend and AI curriculum) that matters most for self-taught web developers in 2026. The Techdegree remains a real differentiator for learners who want coached project reviews. For everyone else, Scrimba is the more current choice and the free tier means you do not have to take that on faith. ## Related Pages - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) | [Scrimba vs Codecademy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-codecademy/) - [Scrimba vs The Odin Project](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-odin-project/) | [Scrimba vs Coursera](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-coursera/) - [Scrimba vs Boot.dev](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-boot-dev/), backend-focused alternative - [Scrimba vs YouTube](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-youtube/), interactive coding vs passive video - [How Scrims Work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/) **Q: Is Treehouse better than Scrimba in 2026?** For modern web development and AI engineering, no. Scrimba's scrim format and current curriculum are stronger. Treehouse is still a real option for the Techdegree or for Java and C# coverage. **Q: Does Treehouse have a free tier?** No, only a 7-day trial. Scrimba offers around 24 full courses for free. **Q: How much does Treehouse cost in 2026?** Courses subscription around $25/mo after a 7-day trial, Techdegree around $199/mo. Verify any middle tier on the live pricing page. **Q: What is the Techdegree?** A coached, project-based program with human-reviewed capstones. Worth it if you specifically need that review; otherwise a self-paced subscription is more cost-effective. **Q: Are Scrimba or Treehouse certificates accredited?** Neither platform offers accredited university credentials. Both offer certificates of completion you can list on LinkedIn. ## Try Scrimba's free courses first Around 24 full courses, no card. Compare the in-player editor to Treehouse's watch-then-practice flow. [Try Scrimba free](https://scrimba.com/?via=u42d4986) ### Related Guides - [All Comparisons](https://scrimbaguide.tech/docs/comparisons/) - [Frontend Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) - [Scrimba vs Codecademy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-codecademy/) --- # Scrimba vs Udemy Source: https://scrimbaguide.tech/docs/comparisons/scrimba-vs-udemy/ Scrimba wins if you are studying web development or AI for months and want a curated subscription that cuts out course-picking friction. Udemy wins for a one-off course you want to own forever, or a specific niche or instructor Scrimba does not cover. Pick on study horizon and topic, not brand loyalty. ## What decides it: cost, curation, or coverage? Lifetime buy vs subscription. Udemy charges per course (sale prices around $10 to $15) and you keep it forever. Scrimba is a single fee covering the full catalogue while you stay subscribed. For one niche course, Udemy wins on raw cost. For 6+ months across React, JavaScript, AI, and backend, the subscription usually beats buying three or four Udemy bestsellers. Marketplace vs curated. Udemy is open enrolment, which is how the catalogue passed 250,000 courses in 2024 ([electroIQ stats](https://electroiq.com/stats/udemy-statistics/)). Quality varies wildly: Udemy's Trustpilot sits at roughly [1.7 / 5](https://www.trustpilot.com/review/udemy.com), with a one-star-dominated distribution (around 27% five-star against 52% one-star as of 2026). Scrimba commissions and reviews courses internally, so the floor is higher and the ceiling is lower. What each platform covers. Scrimba focuses on web and AI engineering: React, JavaScript, TypeScript, Node, Python, plus an [AI Engineer path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) covering agents, RAG, and MCP. Udemy covers all of that plus Unreal Engine, AWS certs, Excel, Photoshop, marketing, and more. If your goal sits outside web and AI, Scrimba is not in the conversation. ## The Verdict Different products, both valid Scrimba wins for the typical web dev or AI learner who will study for months, because interactive scrims and four structured paths reduce the time spent picking courses and the chance of stalling in passive video. Udemy wins for one-off niche courses, learners who want to own content forever, and anyone shopping by specific instructor. ### Pros - Scrimba: code inside the lesson (less tutorial hell) - Scrimba: one fee covers paths plus every course - Scrimba: curated quality floor; Udemy varies per instructor ### Cons - Udemy: lifetime ownership and one-off purchases - Udemy: 250,000 courses cover niches Scrimba ignores - Udemy: top instructors (Schwarzmüller, Grider, Neagoie) often deeper than Scrimba on the same topic [Try the interactive scrim demo](https://scrimba.com/s0v687325e?via=u42d4986) | Feature | Scrimba | Udemy | | --- | --- | --- | | Teaching format | Scrims: the recording pauses at each challenge and you type in the same editor (170+ challenges in Learn React alone) | Passive video lectures | | Pricing model | Monthly or annual subscription | Per-course purchase, often $10 to $15 on sale | | Catalogue size | 73+ curated courses | ~250,000 courses across all topics | | Free content | ~24 full courses | Some free courses; quality varies | | Quality control | Commissioned and reviewed in-house | Open marketplace; quality varies per instructor | | Trustpilot rating | ~4.2/5 (77 reviews) | ~1.7/5 (one-star-dominated) | | Structured paths | 4 career paths up to 108 hours | None native; some instructors bundle their own | | Ownership | Access while subscribed | Lifetime access per course you buy | | Refund policy | 7 days | 30 days, with limits on heavy consumption | | Community | Active Discord (basic free, Pro-only channels) | Per-course Q&A; no central community | [Visit Udemy](https://trk.udemy.com/xJ6YM1) ## Where Udemy clearly wins Top instructors go deeper than the equivalent Scrimba course. Maximilian Schwarzmüller's React: The Complete Guide runs over 70 hours and covers Redux, routing, auth, and testing in more depth than Scrimba's [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) (15.1 hrs) plus [Advanced React](https://scrimbaguide.tech/docs/courses/react/advanced-react/) (18.8 hrs) combined. Stephen Grider's React and Node courses have over 230,000 students at a 4.6 average ([catalogue](https://trk.udemy.com/9Vd0k5)). Andrei Neagoie's Complete React Developer and Brad Traversy's Modern JavaScript From The Beginning are go-to picks for project-based depth; Neagoie also runs his own cohort-style platform, compared in [Scrimba vs Zero to Mastery](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-zerotomastery/). If you already know you want one specific instructor's full course, just buy it. Lifetime ownership. Cancel Scrimba and access ends at the billing period. Buy a Udemy course on sale, let the refund window pass, and it is yours to revisit during a job switch four years later. Niche topics Scrimba does not cover. Unreal Engine, Unity, AWS Solutions Architect prep (see [Scrimba vs Pluralsight](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-pluralsight/) if certification prep is the goal), advanced Excel, Photoshop, Blender, marketing, finance. Scrimba's scope is web and AI; Udemy's is everything. ## Where Scrimba wins The interactive format. Scrim videos let you pause the instructor mid-sentence and edit code in the same player. In [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) the challenges arrive as numbered comments in the file with the recording paused, and every scrim has a timestamped transcript you can search instead of scrubbing. Active-learning research ([Freeman et al., 2014, PNAS](https://www.pnas.org/doi/10.1073/pnas.1319030111)) found students retain and perform better when they practise actively rather than watch passively. On Udemy you watch, then switch to your IDE, which is the gap where tutorial hell starts. Curated floor. When Udemy's distribution is around 27% five-star and 52% one-star, picking the right course is itself a research project. Scrimba's catalogue is commissioned, so Bob Ziroll's React, the AI Engineer path, and the newer MCP and Langbase agent courses share a consistent floor. Structured paths. Udemy has no native path concept; you stitch courses yourself. Scrimba sequences four paths automatically (Frontend 81.6 hrs, Fullstack 108.4 hrs, Backend 36.2 hrs, AI Engineer 11.4 hrs). Current AI engineering coverage. Scrimba now includes AI Agents with Bob Ziroll, [Intro to MCP](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/), Vercel AI SDK, [Build Serverless AI Agents with Langbase](https://scrimbaguide.tech/docs/courses/ai/serverless-ai-agents-with-langbase/), and a course built with Mistral. Finding equally current AI courses inside Udemy's 250,000-course catalogue takes real effort. ## What do Udemy buyers complain about? Three complaints show up repeatedly on Trustpilot and ConsumerAffairs. None are dealbreakers if you mitigate them at purchase time. - Billing and refund disputes. Multiple [ConsumerAffairs](https://www.consumeraffairs.com/education/online-courses/udemy.html) threads document refund denials when "a notable amount of the course has been consumed," which matches [Udemy's policy](https://support.udemy.com/hc/en-us/articles/360050856093-Udemy-s-Refund-Policy). Mitigation: preview at most one section before deciding, then either commit or refund within 30 days. If you bought a Personal Plan subscription instead of a single course, set a calendar reminder 48 hours before auto-renewal to cancel from billing settings. - Outdated content. Marketplace courses age with their instructors; a 2019 Node course can still be a bestseller in 2026. Mitigation: filter by "Last updated" in the URL query and skip anything not refreshed in the last 18 months. - Hard-to-reach support. The AI chatbot routing is widely criticised on Trustpilot. Mitigation: for refund requests, go straight to the [refund form](https://support.udemy.com/hc/en-us/articles/360050856093-Udemy-s-Refund-Policy) rather than chat. These are a tax on the marketplace model itself, not on top instructors actively maintaining their work. The three mitigations above are how marketplace veterans avoid paying it. Scrimba's courses age too. The Chef Claude project in [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) pins a July 2024 React 19 release candidate (the capstones run 18.3), and the course's "Quick AI Update" scrim tells you to upgrade the Anthropic SDK if the Chef Claude challenge errors. The difference is that the course flags it from inside. ## How to combine them, low-risk sequence Many web learners benefit from both. Run them in this order so you commit cash only after the format proves itself: - Start Scrimba Free for one week. Open [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) with Bob Ziroll (all six sections and both capstones are free; only the two Solo Projects need Pro) or [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) with Per Borgen. No card required. - If the pause-and-edit format clicks, upgrade to Scrimba Pro and commit to the first three modules of the Frontend or [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/). - After those three modules, buy exactly one focused Udemy course on sale (filter for 4.5+ stars, 4,000+ recent ratings, "Last updated" within 18 months) for depth on one specific topic Scrimba covered too quickly, or a niche it does not touch at all. - Set a Udemy auto-renewal reminder if you bought a Personal Plan rather than a single course. The rating-plus-recency filter cuts most of Udemy's variance. The sequence above keeps your worst case at one cheap Udemy purchase rather than a sprawling cart. ## Bottom line If your study horizon is months and your goal is web or AI work, Scrimba's subscription plus interactive format is the lower-friction default. If you need lifetime ownership, a one-off niche course, or a specific top-tier instructor like Schwarzmüller or Neagoie, Udemy is the right tool for that job. They aren't competing for the same purchase. ## Related Pages - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) | [Scrimba vs Codecademy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-codecademy/) - [Scrimba vs The Odin Project](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-odin-project/) | [Scrimba vs Coursera](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-coursera/) - [Scrimba vs YouTube](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-youtube/) - [How Scrims Work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/) | [How Scrimba Helps You Escape Tutorial Hell](https://scrimbaguide.tech/docs/how-it-works/tutorial-hell/) - [Best Udemy JavaScript courses](https://scrimbaguide.tech/blog/best-udemy-javascript-courses/) | [Best Udemy React courses](https://scrimbaguide.tech/blog/best-udemy-react-courses/) | [Best Udemy Python courses](https://scrimbaguide.tech/blog/best-udemy-python-courses/) - [All Scrimba Courses](https://scrimbaguide.tech/docs/courses/) | [Learning Paths](https://scrimbaguide.tech/docs/paths/) **Q: Is Scrimba better than Udemy for web development?** For most learners studying React, JavaScript, or AI for more than a couple of months, Scrimba's interactive format and structured paths make it the stronger default. Udemy can match it if you carefully pick a top instructor and build projects yourself, which is the harder path. **Q: Is Scrimba more expensive than Udemy?** Per course, sale-priced Udemy courses (around $10 to $15) are cheaper. Across many topics, Scrimba's single subscription covers 73+ courses plus four career paths, which usually beats buying three or four Udemy bestsellers. **Q: Do I keep Scrimba courses if I cancel?** No. Scrimba is subscription-based, so access ends at your billing period. Udemy purchases are lifetime, which is a real advantage if you want to revisit content years later. **Q: Which top Udemy instructors are worth it?** Maximilian Schwarzmüller (React, Angular, Next.js), Stephen Grider (React, Node, AWS), Andrei Neagoie (full-stack, career-focused), and Brad Traversy (project-based fundamentals) are the names that come up consistently in 4.6+ rated programming courses. ## See what Scrimba Pro covers before you buy individual Udemy courses One subscription, four paths, and the AI engineering catalogue. Compare against the Udemy cart you would otherwise build. Use our partner link to get 20% off the Pro plan. [Claim 20% off Scrimba Pro](https://scrimba.com/our-pricing?via=u42d4986) ### Related Guides - [Scrimba Review](https://scrimbaguide.tech/blog/scrimba-review/) - [Is Scrimba Free? Pro vs Free](https://scrimbaguide.tech/docs/pricing/pro-vs-free/) - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) --- # Scrimba vs YouTube Source: https://scrimbaguide.tech/docs/comparisons/scrimba-vs-youtube/ YouTube is free and covers more code than any other platform, but it rewards watching, not doing. Scrimba puts the same skills inside an editor that pauses until you type. Bob Ziroll teaches React on both: freeCodeCamp mirrors his course as one 16-hour YouTube video, while Scrimba splits it into 170+ interactive challenges and six projects. You have watched Fireship, Net Ninja, Web Dev Simplified, Traversy, and JavaScript Mastery. You can talk about React. You still cannot open a blank editor and ship a small app. YouTube wins on price, breadth, and the 5-minute "how do I X?" lookup. It is weak at one job: getting you to stop watching and start typing. Scrimba's format exists for that job. Use each for what it does well, instead of picking one as your religion. Reviewed inside Scrimba with a Pro account, September 2026: compared against the YouTube channels named below. ## The three decisions you are making This is not "free vs paid." It is three smaller calls in a trench coat. - Free-and-fragmented vs paid-and-curated. YouTube gives you 50 React intros from 50 channels in 50 styles. Some teach hooks first, some start with class components from 2019 that no team uses today. Scrimba gives you one sequence per topic, kept current. Fragmentation is free; curation costs money. - Watch-and-forget vs pause-and-edit. On YouTube, the editor is in another tab. The default action is "keep watching." On Scrimba, the editor is the lesson. The default action is "pause and try it." Defaults are everything for tired learners. - Channel hopping vs sequenced path. "Should I do Net Ninja's React playlist or Web Dev Simplified's? Or wait, Kyle just posted a new one." That decision burns hours every week. A path replaces that with "do the next lesson." ## Tutorial hell, named The pattern has a name because it is universal: tutorial hell. You watch 30 React tutorials, follow along (sometimes), feel like you understand, and still cannot build a todo app from a blank file. The reason is not laziness. It is that watching activates recognition memory ("I have seen this before") while typing activates recall ("I can do this now"). Free video gives you the first kind of memory cheaply and the second kind almost never. If you have switched between Fireship for the dopamine hit, Net Ninja (Shaun Pelling) for long playlists, Web Dev Simplified (Kyle Cobb) for a single topic deep dive, Traversy Media (Brad Traversy) for a project tutorial, and JavaScript Mastery for a portfolio piece, and you still feel stuck, you are not unusual. You have done what the channels reward: more watching. The format rewards completionism, not building. If you have already spent 30+ hours on Net Ninja, Web Dev Simplified, or Fireship without shipping a portfolio project, the diagnostic is not more content; it is a structure mismatch. The next tutorial will not fix it. A format that puts the editor inside the lesson might. See [How Scrimba helps you escape tutorial hell](https://scrimbaguide.tech/docs/how-it-works/tutorial-hell/) for the longer write-up. ## The Verdict Scrimba for structure, YouTube for breadth. Use both. YouTube wins on price (free) and breadth (Fireship, Net Ninja, Web Dev Simplified, Kevin Powell, Traversy, JavaScript Mastery all in one feed). Scrimba wins on the one thing that decides whether beginners ship: forcing you to stop watching and start typing inside the lesson. Bob Ziroll teaches Learn React on both platforms; freeCodeCamp mirrors the 16-hour video version, Scrimba ships the same content as 170+ interactive challenges and 6 projects. If 30+ YouTube hours have not produced a portfolio piece, the issue is structure, not content. Use Scrimba as your spine, YouTube as supplements. ### Pros - Scrimba: editor is the lesson (pause and type, no tab switching) - Scrimba: one sequenced career path replaces channel hopping - Scrimba: same Bob Ziroll React content as freeCodeCamp's YouTube mirror, but interactive; Trustpilot 4.2/5 (77 reviews, September 2026) - YouTube: free forever, every niche topic covered, best in class for 5-minute lookups ### Cons - YouTube: passive default leads to tutorial hell (recognition memory without recall) - YouTube: outdated tutorials never get taken down; you have to filter by date yourself - YouTube: no Discord mentor, no code review channel, comments cannot debug your useEffect [Try a free Scrimba scrim, no signup](https://scrimba.com/s0v687325e?via=u42d4986) ## Format head-to-head: Net Ninja React vs Bob Ziroll React Two of the most-watched React courses are free. Both are taught by experienced instructors. They are not the same product. ### Net Ninja's Full Modern React Tutorial Hosted on YouTube as a 27-video playlist. The intro video ([Full React Tutorial #1 - Introduction](https://www.youtube.com/watch?v=j942wKiXFu8)) frames React as "the most popular JavaScript framework for building web applications" and promises a course that teaches "modern features such as hooks and functional components." The full series is organized into four sections per the official course page: React Basics (13 lessons), useEffect and Fetching Data (7 lessons), React Router (6 lessons), and Forms and POST Requests (6 lessons) ([netninja.dev](https://netninja.dev/p/modern-react-tutorial)). What the format does well: short videos, clear voice, you can scrub or skip. What it does not do: it does not stop you from watching all 27 episodes back-to-back without ever opening VS Code. The friction to start coding is entirely on you. Set up Node, install Vite, copy the file structure, alt-tab between tabs, pause and rewind to match Shaun keystroke-for-keystroke. ### Bob Ziroll's Learn React on Scrimba Same instructor exists on YouTube too. Bob Ziroll's [Learn React full course](https://www.youtube.com/watch?v=bMknfKXIFA8) is mirrored to the [freeCodeCamp YouTube channel](https://www.freecodecamp.org/news/learn-react-2024/) as a 16-hour video. On YouTube, it is one long playthrough. On [Scrimba](https://scrimba.com/learn-react-c0e?via=u42d4986), the same teacher and the same lessons become an interactive course "packed with over 170 coding challenges and six exciting projects" ([freeCodeCamp.org, 2024](https://www.freecodecamp.org/news/learn-react-2024/)). Same teacher. Same React. Different shell. The Scrimba version pauses every few minutes and hands you the editor: the challenge is written as numbered comments in the file, and the recording waits until you press play. Every scrim also carries a timestamped transcript and a "Download as Zip" for the project files. The YouTube version keeps autoplaying. The [Learn React review](https://scrimbaguide.tech/docs/courses/react/learn-react/) walks through all six sections and what each project builds. That is the entire comparison. Format, not content, is what makes one stick and the other slide off. ### What this looks like in practice Watch Bob's freeCodeCamp version for 30 minutes. Notice how many times you nodded along without touching a keyboard. Then open the same content on Scrimba. Notice how the course physically stops and refuses to advance until you finish a challenge in the embedded editor. You are not smarter on Scrimba. The defaults are different. | Feature | Scrimba | YouTube Tutorials | | --- | --- | --- | | Price | Free tier + Pro (see scrimba.com/our-pricing) | Free, ad-supported | | Default action while watching | Pause and type in the lesson | Keep watching | | Editor location | Embedded in every lesson | Separate tab, your IDE | | Setup before lesson 1 | None, runs in browser | Install Node, IDE, project scaffold | | Sequence | 4 career paths, 73+ courses | Playlists per creator, you decide order | | Quality control | Curated, updated for new framework versions | Anyone uploads, outdated tutorials stay live | | Practice built in | 170+ coding challenges in the React course alone, plus short quizzes inside the sections | Optional, find or build your own | | Named instructors | Bob Ziroll, Kevin Powell, Per Borgen, others | Fireship, Net Ninja, Web Dev Simplified, Traversy, JS Mastery | | Community | Discord (basic free), Pro channels for code review and mentors | Comments section per video | | Short-form lookup | Less useful for 'how do I X' one-offs | Best in class for 5-minute answers | | Certificates | Course and path certificates (Pro) | None | [Visit YouTube Tutorials](https://www.youtube.com/) ## The setup tax YouTube adds On YouTube, learning happens in two tabs. You watch a few minutes, pause, switch to your editor, try to copy what you saw, get confused, switch back, and rewind to find the timestamp. Most of those steps are logistics. After enough rounds you stop typing and just watch. Every new tutorial can also mean a new project folder, different dependencies and environment variables that do not match your machine. A beginner can lose the first 30 minutes to "npm not found" before writing a line of the lesson. Scrimba skips that step because every lesson already runs in the browser. Per Borgen's free [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) course runs about 9.4 hours across eight modules, and you build a passenger counter, a blackjack game and a Chrome extension without installing anything. Verdict: if setup is where your YouTube sessions die, the in-browser editor removes the excuse. ## Where YouTube clearly wins - Price. Zero. No regional pricing, no annual decision, no card. - Short-form lookup. "How do I center a div with flexbox in 2026" gets a 4-minute answer from Kevin Powell faster than any structured course can deliver. YouTube is the developer's reference manual. The gap has narrowed since [Scrimba Explain](https://scrimbaguide.tech/docs/how-it-works/scrimba-explain/) arrived: a question typed into it comes back as a short narrated video, and the EXPLAIN button inside a lesson answers about the code in front of you, but the free account gets only 10 of those for life. - Sampling a new topic. Not sure whether you want Rust, Go or Svelte? A few 10-minute overviews cost nothing and tell you whether to go deeper. - Breadth of niche topics. Vintage frameworks, exotic stacks, conference talks, library deep dives, build-your-own-database streams. Scrimba's catalog is focused on web and AI. YouTube covers everything. - Choosing your teacher. If [Fireship](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-fireship/)'s pace works for your brain and Web Dev Simplified does not, YouTube lets you optimize for voice in a way curated platforms cannot. If you are already employed and you need to upskill on one specific topic, YouTube is often the right answer. ## Where Scrimba clearly wins - Sequence. A path tells you what to do next. "Next lesson" beats "browse playlists" for anyone who studies after a full day of work. - Format that forces engagement. The interactive scrim is the whole product. [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) stops 170+ times for a challenge, and Bob says in the intro that the quizzes follow the retrieval-practice formula from Make It Stick. You are not asked to be disciplined. The lesson is disciplined for you. - No tutorial hopping. One teacher, one set of conventions, one app per project. You stop spending energy on "is this creator's style right for me" and put that energy into shipping. - Named Discord support. Basic Discord access is free; Pro adds the Pro-only channels with mentors and code review. YouTube comments cannot answer "why is my useEffect firing twice." - An answer without leaving the lesson. Press EXPLAIN in the scrim header and [Scrimba Explain](https://scrimbaguide.tech/docs/how-it-works/scrimba-explain/) builds a narrated video from that lesson's files, transcript and the line you highlighted. On YouTube the equivalent is a new search and a new tab. ## Combine them properly Most learners who escape tutorial hell end up doing the same thing. - Scrimba is the spine. [Frontend path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/), [Fullstack](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/), or [AI Engineer](https://scrimbaguide.tech/docs/paths/ai-engineer-path/), depending on goal. This is the calendar you keep. If you only want to test the format, [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) is free: about 15 hours across six modules, ending in two capstones, Tenzies and Assembly: Endgame. - YouTube is the spice. Fireship for the weekly news hit. Kevin Powell when CSS confuses you. Theo or Primeagen if you like opinions. A specific Web Dev Simplified video when you hit a wall on one concept. - Build outside both. The point of either is to leave both. Ship something in a blank repo, with no tutorial open in another tab. If your YouTube tab count is climbing and your GitHub commit count is not, that is the signal to flip the ratio. ## The cost question The case for YouTube is that it costs nothing. The hidden cost is time. Without a sequence or an editor in the lesson, you spend hours choosing the next video, setting up projects and rewatching sections you only recognized. Scrimba also runs about 24 free interactive courses, so you can test whether the format sticks for you before paying anything. The [free course list](https://scrimbaguide.tech/blog/best-free-scrimba-courses/) shows what is included, and [Scrimba pricing](https://scrimbaguide.tech/docs/pricing/) covers what Pro adds. Verdict: start free on both, and pay only once the free Scrimba courses have shown you the format works. ## Bottom line Choose Scrimba if: you have already done the YouTube thing and it did not stick. You need defaults that pull you toward typing. You want one sequence instead of forty playlists. Choose YouTube if: you are looking up a specific thing, you cannot pay anything, or you are an experienced dev needing breadth over depth. Use both if: you are a beginner who wants to graduate from beginner. ## Related pages - [How scrims work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/) - [How Scrimba helps you escape tutorial hell](https://scrimbaguide.tech/docs/how-it-works/tutorial-hell/) - [Scrimba vs Fireship](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-fireship/) - [Scrimba vs Udemy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-udemy/) - [Scrimba vs freeCodeCamp](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-freecodecamp/) - [Best free Scrimba courses](https://scrimbaguide.tech/blog/best-free-scrimba-courses/) - [Scrimba Review 2026](https://scrimbaguide.tech/blog/scrimba-review/) ## Sources cited - Net Ninja, [Full React Tutorial #1 - Introduction](https://www.youtube.com/watch?v=j942wKiXFu8), YouTube - Net Ninja, [Modern React Tutorial course outline](https://netninja.dev/p/modern-react-tutorial) - Bob Ziroll / freeCodeCamp, [Learn React full course on YouTube](https://www.youtube.com/watch?v=bMknfKXIFA8) - Beau Carnes, [Learn React from Bob Ziroll (freeCodeCamp.org, 2024)](https://www.freecodecamp.org/news/learn-react-2024/) - Scrimba, [Learn React with Bob Ziroll](https://scrimba.com/learn-react-c0e?via=u42d4986) - Scrimba, [official pricing page](https://scrimba.com/our-pricing?via=u42d4986) **Q: Why pay for Scrimba when YouTube is free?** YouTube wins on price and breadth, but its passive default leads most beginners into tutorial hell. Scrimba puts the editor inside the lesson so the default action becomes typing instead of watching. For beginners, that format change usually matters more than the price difference. **Q: Is YouTube enough to learn to code?** For disciplined learners who set up their own projects and force themselves to build alongside videos, yes. Most beginners get stuck with strong recognition memory and weak recall, which is the textbook tutorial hell pattern. **Q: Can I learn to code entirely for free on YouTube?** You can cover a lot, but you assemble your own curriculum and handle every project setup yourself. Scrimba also runs about 24 free interactive courses if you want structure without paying. **Q: Net Ninja vs Scrimba for React?** Same modern React, two formats. Net Ninja's YouTube playlist is free and self-directed. Bob Ziroll's Scrimba course is interactive with 170+ challenges and 6 projects built inside the lesson. **Q: Which YouTubers pair well with Scrimba?** Fireship for weekly awareness, Kevin Powell for CSS, Web Dev Simplified for single-topic deep dives, Traversy Media for project tutorials, Net Ninja for long playlists, JavaScript Mastery for portfolio builds. **Q: Can I just watch Bob Ziroll's React course on freeCodeCamp YouTube instead of paying Scrimba?** Yes, the same content is there as a 16-hour video. You lose the interactive editor, the 170+ challenges and quizzes, and the per-scrim transcript. The free Scrimba version also comes with basic Discord access; only the two Solo Projects, the certificate and the Pro-only Discord channels need Pro. If you can stay disciplined through 16 hours of YouTube and code along in your own editor, you do not need to pay. Most learners benefit from the format change. **Q: Does Scrimba have anything like searching YouTube when I am stuck?** Yes, Scrimba Explain. Press EXPLAIN inside any lesson, or type a question into the Explain tool directly, and you get a narrated video answer with diagrams and a quiz instead of a search results page. Free accounts get 10 explainers for life, Pro gets 100 a month. See the [Scrimba Explain reference](https://scrimbaguide.tech/docs/how-it-works/scrimba-explain/). ## Trade tutorial hopping for one sequenced path If 30+ YouTube hours have not produced a shipped project, Pro unlocks the Frontend, Fullstack, Backend, and AI Engineer paths with the interactive editor built in. Live pricing at scrimba.com/our-pricing. Use our partner link to get 20% off the Pro plan. [Claim 20% off Scrimba Pro](https://scrimba.com/our-pricing?via=u42d4986) ### Related Guides - [How Scrims Work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/) - [Best Free Courses](https://scrimbaguide.tech/blog/best-free-scrimba-courses/) - [Is Scrimba Free? Pro vs Free](https://scrimbaguide.tech/docs/pricing/pro-vs-free/) --- # Scrimba vs Zero to Mastery Source: https://scrimbaguide.tech/docs/comparisons/scrimba-vs-zerotomastery/ ZTM Academy is Andrei Neagoie's cohort-style platform: long video courses, a lead-instructor brand, and an alumni Discord. Scrimba is the self-paced alternative: shorter courses, scrims where the editor sits inside the video, and multiple specialist instructors instead of one. Both produce a working developer. Pick ZTM for cohort scaffolding and one voice throughout; pick Scrimba to set your own week and switch teachers per topic. Reviewed inside Scrimba with a Pro account, September 2026. ## The one-sentence framing ZTM is a cohort-style bootcamp on the internet anchored by Andrei Neagoie. Scrimba is the truly self-paced alternative anchored by the scrim format. Same outcome possible; very different study habit required. ## The Verdict Self-paced scrims vs cohort-style bootcamp Scrimba wins as the truly self-paced alternative. Code inside the video, no cohort, no fixed weekly pace, switch instructors per topic. ZTM wins on cohort-style structure with Andrei Neagoie as the lead voice, broader language coverage (Python, Java, Rust), and a lifetime plan. Pick by whether you finish more when peers are doing the same modules with you, or whether you finish more when nobody is setting your week. ### Pros - Scrimba: code inside the instructor's video - Scrimba: multiple specialist instructors per topic - Scrimba: stronger AI engineering coverage (agents, RAG, MCP) - Scrimba: about 24 full courses free, no card - ZTM: large catalog with strong Python, Java, and Rust coverage - ZTM: lifetime plan available (one-time payment) - ZTM: established alumni community and bootcamp roadmaps ### Cons - Scrimba: narrower language coverage; light on Java, Rust, Go - Scrimba: not bootcamp-cohort style; self-paced only - ZTM: mostly traditional video; passive without active code-along - ZTM: limited free tier; previews only - ZTM: heavy reliance on one lead instructor's pace and style [Try a scrim in your browser](https://scrimba.com/s0v687325e?via=u42d4986) | Feature | Scrimba | Zero to Mastery | | --- | --- | --- | | Teaching format | Video scrims that pause at each challenge; you type in the same editor | Traditional video lectures + exercises | | Pricing model | Monthly or annual | Monthly $39-$49; annual $299-$399; lifetime ~$1,299 | | Free tier | ~24 full courses, no card | Free previews only | | Catalog size | 73+ focused courses | 170+ courses across many stacks | | Career paths | 4 paths (up to 108 hrs) | Career roadmaps anchored by bootcamps | | Languages | JS, TypeScript, Python, HTML/CSS, SQL | JS, Python, Java, Rust, Go, and more | | AI engineering | 12 courses (agents, RAG, MCP) | ML & AI bootcamp; lighter on modern AI tooling | | Instructor model | Multiple specialists per topic | Andrei Neagoie as lead, plus invited co-instructors | | Community | Active Discord (basic free, Pro-only channels) | ZTM Academy Discord (alumni + students) | | Certificates | Course and path certificates (Pro) | Course certificates | | Lifetime plan | Not offered | Yes (~$1,299 one-time) | | Money-back guarantee | Refund window per terms | 30-day money-back guarantee | [Visit Zero to Mastery](https://zerotomastery.io/) ## Bootcamp-style cohorts vs self-paced paths ZTM is structured like an internet bootcamp. The flagship "Complete Web Developer in 2026" course is around 40 hours of traditional video; the "Complete Python Developer" course is 32 hours; the "Complete A.I. Machine Learning and Data Science Bootcamp" is 45 hours. The platform is built around bootcamp-length commitments, and the [ZTM Academy](https://zerotomastery.io/about/instructor/andrei-neagoie/) Discord runs like an alumni network where students discuss exercises and roadmap progress together. Since 2018, over a million students have moved through this model. Scrimba is self-paced and interactive. Courses are shorter; scrims are the unit; the editor is always one keystroke away. The [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) is 81.6 hours but split into many small interactive segments. There's no cohort, no fixed pace, no Friday lecture. Some learners need the bootcamp scaffolding to finish. Others stall inside it and prefer to set their own week. ## Andrei's specific style vs multiple Scrimba instructors This is the defining choice. ZTM is Andrei Neagoie's brand. He's the lead instructor and the platform's voice. You either click with his pacing, opinions, and teaching style or you don't. He's been one of the top-rated instructors in his category for years, so a lot of people do click. Other ZTM instructors join for specific topics, but the through-line is his. Scrimba is multi-instructor by design. Bob Ziroll teaches React (and opens the TypeScript course, which Rachel Johnson carries), Per Borgen the JavaScript and HTML/CSS basics, Treasure Porth Python, Tom Chant Node and Express, and others lead AI engineering and cybersecurity. The voice shifts by topic. The upside: you get the specialist's depth on each subject. The downside: less narrative continuity across your whole journey. If you tried Andrei's courses on Udemy years ago and they worked, ZTM is a direct continuation. If you didn't get on with his pace or you want different teachers for different topics, Scrimba is the better fit. ## Alumni community vs Scrimba Discord ZTM's Discord is built around the bootcamp roadmaps. Students and alumni discuss the same long courses, share project critiques, and circulate job referrals. The community has tenure; some members have been there for years. Scrimba's Discord runs more like a working learning forum. Basic access is free; Pro adds the Pro-only channels where instructors drop in and code reviews happen, plus project channels per path. Less of an alumni feel, more of a working learner's room. Both are useful. ZTM's may feel deeper if you want to spend years with the same cohort. Scrimba's feels tighter to the lessons you're inside this week. ## Where ZTM wins outright - Language breadth: Strong Python, Java, Rust, Go, and ML coverage. Scrimba's catalog stops short on those. - Lifetime plan: Around $1,299 one-time gets you every course, all future updates included. The math beats annual subscriptions over a multi-year horizon. - Bootcamp scaffolding: For learners who need a long, structured course with a single instructor and an alumni Discord, ZTM is purpose-built for that. - Refund certainty: A documented 30-day money-back guarantee. ## Where Scrimba wins outright - Interactive format: Code inside the lesson is hard to give up once you've felt it, especially for visual concepts like CSS, React, and animations. In [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) the recording stops 170+ times for a challenge, and every scrim has a transcript panel. [Learn Python](https://scrimbaguide.tech/docs/courses/python/learn-python/) swaps the preview pane for a terminal, so the loop is the same on ZTM's home turf. - AI engineering depth: 12 courses on agents, RAG, MCP, and the Vercel AI SDK. ZTM has an ML bootcamp; it doesn't have the modern AI app shipping stack at this depth. - Free tier: About 24 full courses, no card required. ZTM's free layer is previews only. - Lower commitment to a single voice: Multiple specialists means a bad-fit instructor on one topic doesn't tank the whole subscription. ## Use both if You want ZTM's Python bootcamp for one stack and Scrimba's interactive React + AI engineering paths for the other. Scrimba's own [Learn Python](https://scrimbaguide.tech/docs/courses/python/learn-python/) is a single free 4.1-hour course of three small terminal apps (an expense splitter, a word game, a karaoke queue), a primer rather than a bootcamp. The lifetime ZTM plan plus a few months of Scrimba works for a self-taught dev targeting a fullstack-plus-AI profile. ## Bottom line Both platforms can produce a working developer. The question is which study habit you'll keep. If you've finished long video courses before and you like a single instructor's voice across a journey, ZTM is built for you. If long video makes you drift and you need the editor in the lesson to stay engaged, Scrimba's format is the unlock. Try Scrimba's free tier first; it costs nothing and tells you within a weekend whether scrims work for your brain. ## Related Pages - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) | [Scrimba vs Udemy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-udemy/) - [Scrimba vs Codecademy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-codecademy/) | [Scrimba vs freeCodeCamp](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-freecodecamp/) - [Frontend Developer Path Review](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) | [All Comparisons](https://scrimbaguide.tech/docs/comparisons/) - [How Scrims Work](https://scrimbaguide.tech/docs/how-it-works/how-scrims-work/) - [All Scrimba Courses](https://scrimbaguide.tech/docs/courses/) | [Scrimba Review 2026](https://scrimbaguide.tech/blog/scrimba-review/) ## Sources - [ZTM courses catalog](https://zerotomastery.io/courses/) - [Andrei Neagoie instructor profile (ZTM)](https://zerotomastery.io/about/instructor/andrei-neagoie/) - [Complete Web Developer in 2026 (ZTM)](https://zerotomastery.io/courses/coding-bootcamp/) - [ZTM Academy review (CyberSchoolers, 2026)](https://www.cyberschoolers.com/platform-reviews/zero-to-mastery-review/) - [ZTM lifetime plan review (Javarevisited, 2026)](https://medium.com/javarevisited/review-is-zero-to-mastery-academy-lifetime-plan-worth-it-in-2025-366b55a47d8c) **Q: Is Scrimba better than Zero to Mastery?** For learners who want an editor inside the lesson and don't mind a narrower catalog, yes. ZTM is better for bootcamp-style depth across more languages and one lead instructor's voice. **Q: Which is cheaper, Scrimba or ZTM?** Both vary. ZTM's annual runs ~$299-$399 with a ~$1,299 lifetime. Scrimba's personal annual is typically lighter and includes ~24 full free courses with no card. **Q: Is the ZTM lifetime plan worth it?** If you'll use it for more than three years, the math beats annual subscriptions. Skip if you're not sure traditional video works for you. **Q: Can I use both?** Yes. ZTM for Python or ML, Scrimba for interactive React or AI engineering paths is a common combo. ## Scrimba Pro is the self-paced alternative to ZTM lifetime A subscription rather than a lifetime bet. If self-paced scrims keep you coding when a long ZTM lecture wouldn't, Pro is the lower-commitment way to find out across a quarter. Use our partner link to get 20% off the Pro plan. [Claim 20% off Scrimba Pro](https://scrimba.com/our-pricing?via=u42d4986) ### Related Guides - [All Comparisons](https://scrimbaguide.tech/docs/comparisons/) - [Fullstack Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) - [Scrimba vs Udemy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-udemy/) --- # All Scrimba Courses Source: https://scrimbaguide.tech/docs/courses/ Scrimba runs 73+ interactive courses across React, JavaScript, AI, CSS, backend, Python, and TypeScript. 24 full courses are free with no card, including [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) and [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/); the rest need [Scrimba Pro](https://scrimbaguide.tech/docs/pricing/). New to code? Start with a free course below. Want a structured sequence to a portfolio? Use a [learning path](https://scrimbaguide.tech/docs/paths/) instead. Reviewed inside the courses with a Pro account, September 2026. ## Browse by Topic | Topic | Courses | Highlights | | --- | --- | --- | | [React](https://scrimbaguide.tech/docs/courses/react/) | 10+ courses | [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/), [Advanced React](https://scrimbaguide.tech/docs/courses/react/advanced-react/), React 19, Router | | [JavaScript](https://scrimbaguide.tech/docs/courses/javascript/) | 30+ courses | Beginner to advanced, interview prep, ES6+ | | [AI & Machine Learning](https://scrimbaguide.tech/docs/courses/ai/) | 11+ courses | Agents, RAG, LangChain, OpenAI, Claude, MCP | | [CSS & Design](https://scrimbaguide.tech/docs/courses/css/) | 12+ courses | Tailwind, Grid, Flexbox, animations, UI design | | [Backend & Databases](https://scrimbaguide.tech/docs/courses/backend/) | 4+ courses | SQL, Supabase, Firebase, Regex | | [Python](https://scrimbaguide.tech/docs/courses/python/) | 1 course | [Learn Python](https://scrimbaguide.tech/docs/courses/python/learn-python/) (4.1 hrs, beginner) | | [TypeScript](https://scrimbaguide.tech/docs/courses/typescript/) | 1 course | [Learn TypeScript](https://scrimbaguide.tech/docs/courses/typescript/learn-typescript/) (4.2 hrs, intermediate) | ## Inside the courses One chapter card per topic, from the course to open first, plus one thing the review found. ![Chapter card from Scrimba's Learn React course announcing the Chef Claude project](https://scrimbaguide.tech/img/scrimba/learn-react/chapter-03-chef-claude-title-card.webp) *React: Learn React, section 3, where the form starts calling the Claude API.* ![Chapter card from Scrimba's Learn JavaScript course for the passenger counter build](https://scrimbaguide.tech/img/scrimba/learn-javascript/chapter-passenger-counter-title-card.webp) *The first build in Learn JavaScript: a passenger counter, 30 scrims and 82 minutes before you touch anything harder.* ![Module 1 card from Scrimba's Learn to Code with AI course](https://scrimbaguide.tech/img/scrimba/learn-to-code-with-ai/chapter-1-learn-to-code-with-ai-title-card.webp) *Nothing is gated in Learn to Code with AI: no Pro items, no solo project, nothing to unlock.* ![Chapter card from Scrimba's Learn HTML and CSS course opening the CSS module](https://scrimbaguide.tech/img/scrimba/learn-html-and-css/chapter-lets-learn-css-title-card.webp) *CSS: Learn HTML and CSS, where the Google.com clone gets styled after being built in plain HTML.* ![Opening card from Scrimba's Learn SQL course, taught by Gregor Thomson](https://scrimbaguide.tech/img/scrimba/learn-sql/chapter-1-intro-to-sql-title-card.webp) *Sixty-two challenges across 49 scrims run on one database in Learn SQL, and none of it is Pro.* ![Opening card from Scrimba's Learn Python course, taught by Treasure Porth](https://scrimbaguide.tech/img/scrimba/learn-python/chapter-1-learn-python-title-card.webp) *Starting with PayUp, Learn Python builds three terminal apps, then stops short of classes or files.* ![Section 1 card from Scrimba's Learn TypeScript course, taught by Bob Ziroll](https://scrimbaguide.tech/img/scrimba/learn-typescript/chapter-1-typescript-fundamentals-title-card.webp) *TypeScript: Learn TypeScript, where a pizza app moves to .ts and seven red lines appear before any fix.* Chapter title cards from scrimba.com. - [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/): six sections, both capstones, and about 180 scrims are free. Pro gates the two solo projects. - [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/): the calculator challenge writes the bug first, so `'Sum: ' + 8 + 2` renders "Sum: 82" before Per fixes it. The three solo projects are Pro. - [Learn to Code with AI](https://scrimbaguide.tech/docs/courses/ai/to-code-with-ai/): nothing is gated, not even a solo project. Guil says up front it is not a programming course; [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) is the LLM plumbing. - [Learn HTML and CSS](https://scrimbaguide.tech/docs/courses/css/html-and-css/): the Google.com clone starts as plain HTML in module one and gets its CSS in module two. The Hometown Homepage solo project is free; three others are Pro. - [Learn SQL](https://scrimbaguide.tech/docs/courses/backend/sql/): 62 challenges across 49 scrims, all on one classic-car dealership database. Nothing is Pro. - [Learn Python](https://scrimbaguide.tech/docs/courses/python/learn-python/): three terminal apps, PayUp first. It stops at functions and try/except: no dictionaries, classes, or files. - [Learn TypeScript](https://scrimbaguide.tech/docs/courses/typescript/learn-typescript/): Bob writes a buggy pizza restaurant in JavaScript, moves it to a .ts file, and seven red underlines appear before a line changes. ## Career Paths For structured learning from beginner to job-ready, check out the [Learning Paths](https://scrimbaguide.tech/docs/paths/): - [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/), 81.6 hrs - [Fullstack Developer Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/), 108.4 hrs - [Backend Developer Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/), 36.2 hrs - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/), 11.4 hrs ## Free Courses These courses are available without a Pro subscription: - [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/) (15.1 hrs) - [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) (9.4 hrs) - [Learn HTML and CSS](https://scrimbaguide.tech/docs/courses/css/html-and-css/) (5.7 hrs) - [Learn TypeScript](https://scrimbaguide.tech/docs/courses/typescript/learn-typescript/) (4.2 hrs) - [Learn Python](https://scrimbaguide.tech/docs/courses/python/learn-python/) (4.1 hrs) - [What's New in React 19?](https://scrimbaguide.tech/docs/courses/react/whats-new-in-react-19/) - [Build Serverless AI Agents with Langbase](https://scrimbaguide.tech/docs/courses/ai/serverless-ai-agents-with-langbase/) - And more. See [Best Free Scrimba Courses](https://scrimbaguide.tech/blog/best-free-scrimba-courses/) ## Practice Guides Stop reading documentation and start coding. Check out our interactive practice guides: - [Practice CSS Grid](https://scrimbaguide.tech/docs/practice/practice-css-grid/) - [Practice Flexbox](https://scrimbaguide.tech/docs/practice/practice-flexbox/) - [Practice React Hooks](https://scrimbaguide.tech/docs/practice/practice-react-hooks/) - [Practice JavaScript Arrays](https://scrimbaguide.tech/docs/practice/practice-javascript-arrays/) - [Practice API Calls](https://scrimbaguide.tech/docs/practice/practice-api-calls/) ## Where to start New to code? Start with [Learn HTML and CSS](https://scrimbaguide.tech/docs/courses/css/html-and-css/): free, no prerequisites. Already writing basic JavaScript? Go straight to [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/). Want one sharp skill instead of a full sequence (React, TypeScript, a single AI topic)? Grab a course row from the topic table above. Comparing against paid options across every topic? See our [best coding courses on Udemy](https://scrimbaguide.tech/blog/best-udemy-coding-courses/) ranking. A [career path](https://scrimbaguide.tech/docs/paths/) bundles courses in order toward hireable projects. Pro unlocks the full sequence, Discord, and certificates. **Q: How many courses does Scrimba have?** 73+ courses across React, JavaScript, AI, CSS, backend, Python, and TypeScript, plus four career paths that bundle them in order. The count drifts as Scrimba retires and launches courses; this site refreshes it from Scrimba's own data. **Q: Which Scrimba courses are free?** 24 courses are free with no card, including Learn React, Learn JavaScript, Learn HTML and CSS, Learn TypeScript, Learn Python, Learn Node.js, Learn Next.js, and Learn SQL. See the ranked list on our best free Scrimba courses page. **Q: Can you download Scrimba courses?** No. Scrims are interactive recordings that run in the browser, not video files, so there is no official download and no offline mode. Anything advertising a Scrimba course download is a pirated copy of a course most of which are free to take legitimately anyway. **Q: Which Scrimba course should I start with?** Complete beginners: Learn HTML and CSS, then Learn JavaScript. If you can already write basic JavaScript: Learn React. JavaScript developers who want AI skills: Learn to Code with AI, then the AI Engineer Path. **Q: Are Scrimba courses worth it?** For frontend and JavaScript-first AI engineering, yes, and the free ones cost nothing to test. For Java, C#, mobile, or data science, no; Scrimba does not cover them. ## Related Pages - [Scrimba Pricing](https://scrimbaguide.tech/docs/pricing/) | [Pro vs Free](https://scrimbaguide.tech/docs/pricing/pro-vs-free/) - [Scrimba vs Codecademy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-codecademy/) - [Scrimba Review 2026](https://scrimbaguide.tech/blog/scrimba-review/) ## Open the catalog on Scrimba Start with free courses to test the scrim format, then upgrade to Pro for every course and all four paths. Use our partner link for 20% off Pro when you are ready. [Try Scrimba free](https://scrimba.com/?via=u42d4986) ### Related Guides - [Learning Paths](https://scrimbaguide.tech/docs/paths/) - [Is Scrimba Free? Pro vs Free](https://scrimbaguide.tech/docs/pricing/pro-vs-free/) - [Best Free Courses](https://scrimbaguide.tech/blog/best-free-scrimba-courses/) --- # Scrimba AI Courses Source: https://scrimbaguide.tech/docs/courses/ai/ Scrimba runs 12 AI courses in JavaScript and TypeScript, covering prompt engineering, agents, RAG, MCP, and the Vercel AI SDK for web developers who want to ship AI features, not train models. Start with the free [Learn to Code with AI](https://scrimbaguide.tech/docs/courses/ai/to-code-with-ai/). Several sequence into the 11.4-hour [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) on Scrimba Pro. Reviewed inside the courses with a Pro account, September 2026. Looking for the full path review? [The AI Engineer Path review](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) covers all nine modules, the 162 scrims, and what the path skips. ## Where to start Start with the free [Learn to Code with AI](https://scrimbaguide.tech/docs/courses/ai/to-code-with-ai/) (4.5 hrs) or the free [Intro to Mistral AI](https://scrimbaguide.tech/docs/courses/ai/mistral-ai/) (1.4 hrs) to try the workflow before committing to the deeper engineering courses. Scrimba's docs also include a free written [How AI Works handbook](https://docs.scrimba.com/how-ai-works/introduction?via=u42d4986), covering the concepts behind this track: LLMs, prompting, embeddings, RAG, agents, and evals, with a Beginner, Intermediate, and Deep Dive depth switcher. Its code examples lean Python, but the ideas map onto the JavaScript patterns these courses teach. Weighing Scrimba against other places to learn this stack? [The best AI engineering courses of 2026](https://scrimbaguide.tech/blog/best-ai-engineering-courses/) lines up the paid and free options. Looking at machine learning specifically rather than AI engineering? [The best AI and machine learning courses on Udemy](https://scrimbaguide.tech/blog/best-udemy-ai-courses/) covers Andrei Neagoie, Kirill Eremenko, and Krish Naik's picks. [Start Learn to Code with AI for free](https://scrimba.com/learn-to-code-with-ai-c02m?via=u42d4986) ## All AI courses | Course | Level | Access | Length | | --- | --- | --- | --- | | [Learn to Code with AI](https://scrimbaguide.tech/docs/courses/ai/to-code-with-ai/) | Beginner | Free | 4.5 hrs | | [Prompt Engineering for Web Developers](https://scrimbaguide.tech/docs/courses/ai/prompt-engineering-for-web-developers/) | Intermediate | Pro | 3.1 hrs | | [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) | Intermediate | Pro | 2.5 hrs | | [Intro to Mistral AI](https://scrimbaguide.tech/docs/courses/ai/mistral-ai/) | Intermediate | Free | 1.4 hrs | | [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) | Intermediate | Pro | 2.0 hrs | | [Build Serverless AI Agents with Langbase](https://scrimbaguide.tech/docs/courses/ai/serverless-ai-agents-with-langbase/) | Intermediate | Free | 50 min | | [Build a Support Agent with Vercel AI SDK](https://scrimbaguide.tech/docs/courses/ai/a-support-agent-with-vercel-ai-sdk/) | Intermediate | Pro | 1.9 hrs | | [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) | Intermediate | Pro | 1.6 hrs | | [Learn Context Engineering](https://scrimbaguide.tech/docs/courses/ai/context-engineering/) | Intermediate | Pro | 60 min | | [Intro to Model Context Protocol (MCP)](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/) | Intermediate | Pro | 37 min | | [Intro to Dall-E and GPT Vision](https://scrimbaguide.tech/docs/courses/ai/dall-e-and-gpt-vision/) | Intermediate | Pro | 1.0 hrs | | [OpenAI Assistants API](https://scrimbaguide.tech/docs/courses/ai/openaiassistants/) | Intermediate | Pro | 30 min | The OpenAI Assistants API course covers a legacy API that OpenAI is winding down in favour of its newer Responses API, so treat it as useful background rather than the current recommended approach. ## Inside the courses ![Module 1 title card of Scrimba's free Learn to Code with AI course, the entry point of the AI track](https://scrimbaguide.tech/img/scrimba/learn-to-code-with-ai/chapter-1-learn-to-code-with-ai-title-card.webp) *Learn to Code with AI, module 1: prompting ChatGPT for your first projects.* ![Opening title card of Scrimba's Prompt Engineering for Web Developers course, with line drawings of people in conversation](https://scrimbaguide.tech/img/scrimba/prompt-engineering-for-web-developers/chapter-01-prompt-engineering-title-card.webp) *No app to build, and recorded mid 2023 with ChatGPT and Bard: Prompt Engineering for Web Developers.* ![Welcome title card of Scrimba's free Intro to Mistral AI course naming Per Borgen as teacher](https://scrimbaguide.tech/img/scrimba/intro-to-mistral-ai/chapter-1-intro-to-mistral-ai-title-card.webp) *Intro to Mistral AI, the free course that covers RAG, a function-calling agent, and local inference.* ![ReAct loop flowchart slide from Scrimba's Learn AI Agents course: the model thinks, calls a function, observes, then loops.](https://scrimbaguide.tech/img/scrimba/learn-ai-agents/react-loop-flowchart-title-card.webp) *You hand-code the ReAct loop before switching to function calling in Learn AI Agents.* ![Title slide of Scrimba's Build a Support Agent with Vercel AI SDK course, taught by Mayo Oshin](https://scrimbaguide.tech/img/scrimba/build-a-support-agent-with-vercel-ai-sdk/chapter-1-intro-title-card.webp) *Build a Support Agent with Vercel AI SDK, the one title card in a flat 23-scrim course.* ![Title slide from Scrimba's Intro to Model Context Protocol course reading Building MCP Server in TypeScript/JavaScript](https://scrimbaguide.tech/img/scrimba/intro-to-model-context-protocol-mcp/chapter-building-mcp-server-title-card.webp) *The slide that opens the weather-server build in Intro to MCP.* Chapter title cards from scrimba.com. - [Learn to Code with AI](https://scrimbaguide.tech/docs/courses/ai/to-code-with-ai/): about 15 mini projects, drum kit to Firebase apps, none gated. - [Prompt Engineering for Web Developers](https://scrimbaguide.tech/docs/courses/ai/prompt-engineering-for-web-developers/): no app to build; recorded mid 2023 with ChatGPT and Bard. - [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/): 36 scrims building Gift Genie, ending with the API key moved to Node. - [Intro to Mistral AI](https://scrimbaguide.tech/docs/courses/ai/mistral-ai/): all 25 teaching scrims free, but La Plateforme wants a card on file. - [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/): the same weather agent built twice, ReAct loop then function calling. - [Build Serverless AI Agents with Langbase](https://scrimbaguide.tech/docs/courses/ai/serverless-ai-agents-with-langbase/): 13 free scrims, three of them challenges; Langbase account needed by scrim 4. - [Build a Support Agent with Vercel AI SDK](https://scrimbaguide.tech/docs/courses/ai/a-support-agent-with-vercel-ai-sdk/): embeds Scrimba's own help articles into Supabase; the free scrims end before the SDK. - [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/): 22 scrims ending in ReelRecs, a film recommender on Supabase. - [Learn Context Engineering](https://scrimbaguide.tech/docs/courses/ai/context-engineering/): 15 scrims, six of them challenges with hints, on Vercel AI SDK 5 and OpenRouter. - [Intro to Model Context Protocol (MCP)](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/): one mock-weather tool; MCP Inspector and Claude Desktop appear on slides only. See [MCP explained for JavaScript developers](https://scrimbaguide.tech/blog/mcp-for-javascript-developers/) for what changed underneath the protocol since this course was recorded. ## How to progress Begin with the free [Learn to Code with AI](https://scrimbaguide.tech/docs/courses/ai/to-code-with-ai/), then add [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) for the JS-dev-meets-LLMs foundation. Layer on [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) and [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) for the two core application patterns, then [Intro to Model Context Protocol (MCP)](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/) and [Build a Support Agent with Vercel AI SDK](https://scrimbaguide.tech/docs/courses/ai/a-support-agent-with-vercel-ai-sdk/) for the current plumbing. ## Where it fits Several of these courses sequence into the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) on Scrimba Pro, the single best reason to subscribe in this category. Browse every track on the [Learning Paths hub](https://scrimbaguide.tech/docs/paths/). ## Related - [JavaScript courses](https://scrimbaguide.tech/docs/courses/javascript/), [React courses](https://scrimbaguide.tech/docs/courses/react/), and [all courses](https://scrimbaguide.tech/docs/courses/) - [Practice AI engineering](https://scrimbaguide.tech/docs/practice/practice-ai-engineering/) - [Scrimba pricing](https://scrimbaguide.tech/docs/pricing/) and [Scrimba vs Udemy](https://scrimbaguide.tech/docs/comparisons/scrimba-vs-udemy/) ## Build AI features in JavaScript The AI Engineer Path covers agents, RAG, MCP, and the Vercel AI SDK in one sequence. Free courses let you try the format first. [Try Scrimba free](https://scrimba.com/?via=u42d4986) ### Related Guides - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) - [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) - [Scrimba AI Engineer Path Guide](https://scrimbaguide.tech/blog/scrimba-ai-engineer-path-guide/) --- # Build a Support Agent with Vercel AI SDK Source: https://scrimbaguide.tech/docs/courses/ai/a-support-agent-with-vercel-ai-sdk/ Build a Support Agent with Vercel AI SDK is Mayo Oshin's Pro project course on Scrimba: 114 minutes across 23 scrims, ending in a Supabase-backed support agent that routes each question to retrieval, web search, or a direct answer. It teaches the Vercel AI SDK v5 API, and it earns two evenings if you already know RAG and function calling. Reviewed inside the course with a Pro account, September 2026. ## Quick answer It suits developers who already understand RAG (retrieval augmented generation, where the model answers from documents you fetch for it) and function calling, and want one realistic build on a mainstream SDK. The catch is setup: you need your own OpenAI key and a free Supabase project, and the first half hour goes to other browser tabs before any agent code runs. Start with [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) first if tool calling is still new to you. **Build a Support Agent with Vercel AI SDK** A Supabase-backed support agent that classifies each question and routes it to retrieval, web search, or a direct answer. - Duration: 1.9 hrs - Level: Intermediate - 23 lessons - Taught by [Mayo Oshin](https://scrimba.com/u016k88?via=u42d4986) [View on Scrimba](https://scrimba.com/build-a-support-agent-with-vercel-ai-sdk-c0lk05ahir?via=u42d4986) ## Is it worth your time? Yes, if you are the person it was made for. The course runs just under two hours and spends almost none of that on theory. Every scrim after the first three is a working Node project in Scrimba's runner. You press RUN, `npm install` and `node index.js` execute in the terminal pane, and the output appears next to the code. That format suits an SDK course. You watch `generateObject` return a typed pizza recipe, then a sentiment classification, and then you are asked to write the same thing yourself. By the end you can wire a retrieval tool and a web search tool into one `generateText` call and let the model choose between them. Two things to know before you pay for it. First, it is not self-contained. You need your own OpenAI API key and a free Supabase project, and you paste three environment variables into the scrim's gear menu before anything runs. The course walks you through both signups, but you will spend the first half hour in other browser tabs. Second, Mayo is upfront about the level. In the intro he says "this course is quite advanced. So the code is fairly complex, and the challenges I've set are really gonna make you think and work." He lists five prerequisites: the OpenAI API, basic prompting, the concept of RAG, function calling, and a basic Express server. If two or more of those are new to you, the pace will feel abrupt. The limitation is scope. This is one SDK, one provider (OpenAI, via `@ai-sdk/openai`), one vector store, and one scenario. The routing pattern transfers anywhere, but you will not see streaming, a React frontend, evaluation, or conversation memory. The final UI is a plain HTML page with a textarea and an Ask button, served by a 50-line Express file. ## What you'll learn Scrimba presents this course as a flat list of 23 scrims with no chapter headings. The grouping below is mine, so you can see where the time goes. The durations are the sums of the scrims in each group, rounded to the minute, which is why the five group figures add up to 116 while the unrounded total is closer to 118. ### Course curriculum 5 editorial groups, 23 scrims, about 118 minutes - Module 1: Intro and RAG refresher (12 min, 3 lessons) - Module 2: Supabase as a vector store (27 min, 4 lessons) - Module 3: Vercel AI SDK: text, structured outputs, tools (37 min, 6 lessons) - Module 4: Agentic routing and web search (28 min, 5 lessons) - Module 5: The finished agent and wrap-up (12 min, 5 lessons) I counted 23 scrims in the table of contents in September 2026, including the four housekeeping scrims at the end (Outro, Scrimba Docs, Scrimbassador, certificate). Scrimba's listing and its structured data say 21 lessons and 114 minutes, while the 23 scrims add up to about 118 minutes. The three platform add-ons run 1:18, 1:59, and 0:53, which is four minutes and ten seconds, so Scrimba is evidently leaving them out of its own total. ## Inside the course, scrim by scrim ### 1. Intro and RAG refresher (12 min, 3 scrims) ![Title slide of Scrimba's Build a Support Agent with Vercel AI SDK course: Building a Customer Support AI Agent, teacher Mayo Oshin.](https://scrimbaguide.tech/img/scrimba/build-a-support-agent-with-vercel-ai-sdk/chapter-1-intro-title-card.webp) *This module recaps RAG in slides, then embeds a sample text file with OpenAI's text-embedding-3-small model.* The intro is a slide deck, not code. Mayo makes the case for support as the use case ("customer support is at the heartbeat of every company"). He then shows the finished app answering "How do I join the Scrimba Discord?" with sources, follows it with a web search question, and lists the prerequisites. He introduces himself as an AI engineering educator and "the coauthor of Learning Langchain published by O'Reilly." The RAG refresher is three minutes of slides: store information, retrieve the relevant pieces, pass them to the model. The embeddings model for the whole course is OpenAI's `text-embedding-3-small`. This scrim is also where you are told to create an OpenAI key and save it as `OPENAI_API_KEY` in the scrim's gear menu. The Embeddings Recap is the first code scrim. It is a 14-line `index.js` that calls `openai.embeddings.create` and prints the 1,536-number array. An embedding is that array: a list of numbers that stands in for the meaning of a piece of text, so similar texts produce similar numbers. Mayo nudges you to change the text, save with Ctrl+S, and run again. ### 2. Supabase as a vector store (27 min, 4 scrims) Vector Database Embed Documents is the setup lesson. You create a Supabase organization and project, then copy the public key and the service role key into `SUPABASE_URL` and `SUPABASE_SERVICE_ROLE_KEY`. Next you paste `created_tables.sql` into the Supabase SQL editor. The SQL enables pgvector (the Postgres extension that stores and compares embeddings) and creates a `documents` table with `content`, `metadata jsonb`, and `embedding vector(1536)`. The ingest script embeds a sample text file (Apollo 11, Magna Carta, the Black Death, and so on) and inserts one row. Vector Database Retrieval adds a `match_documents` database function that does cosine similarity, a score from 0 to 1 for how close two embeddings are. A `retrieveSimilarDocs` helper calls it through `supabase.rpc` with the query embedding and a match count of five. Mayo runs the question "In 1843, what was the key milestone in computing?" and gets a similarity of roughly 0.5. He explains why: "this text contains both the relevant information to answer the question ... but it also contains a bunch of other irrelevant information that has nothing to do with the question." The challenge that follows is the last free scrim. The brief in `index.js` reads "Build a basic retrieval system" with four numbered steps: embed the query, write the Supabase RPC call, build the prompt with `getRagPrompt`, send it to the model. The recording stops for you to work and resumes with the solution at 1:57. Text Splitting and Retrieval is the first Pro scrim. It shows a deliberately basic splitter (2,000 characters, 100 overlap) turning a 5,988-character passage on the Great Fire of London into four rows. Mayo is candid that "in this course, for the most part, we are not going to use text splitting, but it is important for you to understand how it works." ### 3. Vercel AI SDK: text, structured outputs, tools (37 min, 6 scrims) This is the core of the course and the part that justifies the title. Vercel AI SDK Basics swaps the raw OpenAI client for `generateText` and `embed` from the `ai` package. The pitch, in Mayo's words: "If I wanna swap OpenAI with Cloud or any other model, it's very easy to do so as opposed to going through each of their documentations." One version note matters. The `package.json` in the later scrims pins `ai` 5.0.x, `@ai-sdk/openai` 2.0.x, `@supabase/supabase-js` 2.56, and `zod` 4.1. That is the AI SDK v5 API (`inputSchema`, `stopWhen`, `stepCountIs`), not the older `maxSteps` style you will still find in many tutorials. The code here will not match a 2024 blog post. The basics challenge (3:28) is a warm-up. Mayo frames it as "replicate the logic before, but we're gonna have a twist." You call `generateText` with a prompt for a recipe for your favorite meal, then pass the returned text into an `embed` call. The solution is pepperoni pizza, and the whole thing fits in two functions. Structured Outputs introduces `generateObject` with a Zod schema. Zod is a small library for describing the shape of an object in JavaScript, and the SDK uses that description to force the model's reply into it. Mayo builds a pizza recipe first (name, ingredients array, steps), then a customer review classifier using `z.enum(["positive", "negative"])` plus a `reasoning` field. The structured outputs challenge (5:58) has two parts. First you write a schema for a sandwich order. `size` is an enum of small, medium, and large, and `bread` is a string. `toasted` is a boolean, `toppings` is an array with at least one entry, and `notes` is optional. Then you write a message classifier with a `reasoning` string and a `label` enum (complaint, question, and so on) and run it on a sample complaint about a buggy app. Mayo calls the second part "constrained classification," and it is the same shape the routing agent uses later. Tool Calling is the longest lesson in the group at nearly ten minutes. It builds up in three functions you uncomment one at a time. The first is a single `weather` tool with `description`, `inputSchema`, and `execute`. The second calls two tools (weather plus `cityAttractions`) from one prompt. The third uses the same two tools with `stopWhen: stepCountIs(3)` so the model summarizes the tool results into a sentence. Mayo's definition is the plainest I have heard: "all a tool is is a function or an action that the model can invoke." ![Build a Support Agent with Vercel AI SDK, tool-calling challenge: code editor showing a commented exercise brief and price table.](https://scrimbaguide.tech/img/scrimba/build-a-support-agent-with-vercel-ai-sdk/tool-calling-challenge-brief-lesson.webp) *The tool-calling challenge at 0:30. The prices are fake, a stand-in for the database the priceLookup tool would otherwise query.* Screenshot of scrimba.com, taken by scrimbaguide.tech. The tool-calling challenge mirrors the lesson exactly. You write a `priceLookup` tool over a five-item grocery table, then a `deliveryEta` tool, then add `stopWhen(stepCountIs(3))` to get a summary ("The total cost for eggs is three point two nine dollars ... the estimated delivery time to the address is twenty six minutes"). Each of the three parts has TODO comments where you fill in the Zod schema and the `execute` body. ### 4. Agentic routing and web search (28 min, 5 scrims) ![Build a Support Agent with Vercel AI SDK, Agentic Retrieval Routing slide: a flowchart splits a question into two answer paths.](https://scrimbaguide.tech/img/scrimba/build-a-support-agent-with-vercel-ai-sdk/chapter-4-basic-agent-routing-slide.webp) *This module classifies each question as GENERAL or RETRIEVAL, then adds OpenAI's web search tool alongside the knowledge base.* Slides from scrimba.com. Agentic Retrieval Routing is the longest scrim in the course at 13:45 and the one where the project becomes a support agent. The docs folder now holds nine markdown files scraped from Scrimba's help center (joining Discord, student discounts, resetting progress, deleting your account). `agenticRetrieval.js` adds a `classifyAndRetrieve` function. A classification prompt with `maxOutputTokens: 20` and `temperature: 0` returns either `GENERAL` or `RETRIEVAL`, and the code branches on that word, with a fallback prompt if retrieval returns nothing. Mayo explains the settings plainly: "I want zero because I just want retrieval or just give me general. I don't want the model to express any creativity whatsoever." ![Build a Support Agent with Vercel AI SDK, Agentic Retrieval Routing lesson: code editor and terminal output showing the classifier's result.](https://scrimbaguide.tech/img/scrimba/build-a-support-agent-with-vercel-ai-sdk/agentic-retrieval-routing-general-classification-lesson.webp) *At 13:07 the same agent answers an off-topic question without touching the vector store: the classifier returns GENERAL and the sources come back null.* Screenshot of scrimba.com, taken by scrimbaguide.tech. The routing challenge (3:13) is the smartest of the six, because it changes the design rather than repeating it. You refactor the plain-text classifier into a `generateObject` call with a Zod schema: a `reasoning` string and a `type` enum of `retrieval` or `general`. Mayo's tip is worth keeping: "The first thing I usually recommend is you pass in the reasoning so you can see what reasoning the model wants to give." When he runs it, the Discord question comes back typed `retrieval` with a one-line justification, and the answer follows as before. Web Search AI Agent is a 30-line file showing `openai.responses('gpt-4o-mini')` with `tools: { web_search_preview: openai.tools.webSearchPreview({}) }`. The call returns `text` plus a `sources` array of URLs. The recording dates itself here: the answer to "What is the latest OpenAI large language model?" is GPT-5 "as of September twenty twenty five." Web Search Plus Retrieval Agent is the payoff. The whole Supabase retrieval flow is wrapped into a `knowledgeBaseSearch` tool, the web search tool sits beside it, and a system prompt tells the model when to use each. `stopWhen: stepCountIs(3)` lets the model call a tool and then write its answer. The last challenge asks you to re-add the two tools and the `generateText` properties from memory. ### 5. The finished agent and wrap-up (12 min, 5 scrims) Complete Customer Support AI Agent is a six-minute tour rather than a build. Everything from the previous lesson moves behind an Express `POST /api/ask` route, with `index.html`, `style.css`, and `client.js` served as static files. The preview pane shows the running app on port 3000. ![Build a Support Agent with Vercel AI SDK, finished agent lesson: code editor beside a live chatbot preview answering a support question with sources.](https://scrimbaguide.tech/img/scrimba/build-a-support-agent-with-vercel-ai-sdk/complete-support-agent-knowledge-base-answer-lesson.webp) *At 0:57 of the finished app, the Discord question routes to the knowledge base tool: three chunks come back, and View Sources shows the markdown article and its 0.7275 similarity.* Screenshot of scrimba.com, taken by scrimbaguide.tech. Mayo then asks "how do I resolve the error node_modules not found?", which the agent sends to web search instead. He walks through the architecture slide: does this need retrieval, and if so, is it real-time information or something in the vector store? His closing advice is to swap in your own documents or a different use case entirely. The Outro recaps the five things you built and suggests a stretch goal: "refactor the final project for your use case ... maybe you wanna build your own travel agent." The last three scrims are the platform-wide add-ons Scrimba appends to most courses, and none of them is about the Vercel AI SDK. Scrimba Docs (1:18) is Tom Chant introducing the free reference docs, "a companion to our lessons" with three depth levels. Want to become a Scrimbassador? (1:59) is Per Borgen pitching the referral program. How to Utilize Your Certificate (0:53) tells you to add the certificate to LinkedIn and connect with Per. You can skip all three without missing anything. ## What a lesson feels like Scrims run from under a minute to 13:45; most are three to seven minutes. Because this is a Node course, the layout differs from Scrimba's frontend courses. There is a file explorer on the left, Monaco (the same editor VS Code uses) in the middle, and a Runner/Terminal/Console pane below with an `npm run start` button. Mayo narrates over the finished code, comments and uncomments function calls in `main()`, and presses RUN so you watch the output arrive. There is no live preview until the final lesson, where the browser pane appears on the right. All six challenges arrive as comment blocks in `index.js` with numbered goals and TODO markers, and the scrubber shows a purple dot where the recording pauses. Mayo gives you "a couple minutes," and his solutions are brisk ("Hopefully, you didn't find that too challenging"). He types them out rather than pasting. Each scrim has captions, a timestamped transcript under the settings menu, and subtitles in ten languages. The six challenge scrims carry Scrimba's "Challenge with Instant Feedback" icon in the table of contents, meaning you can ask for an AI check on your solution. ## Free or Pro: exactly what is gated The first six scrims are marked SAMPLE and open without a subscription: the three intro scrims, the two Supabase setup lessons, and the first challenge. That is 32 minutes, and it gets you as far as a working single-document RAG query against Supabase. When I opened the seventh scrim in a browser without a Scrimba session, it showed an "Only available to subscribers" wall. Pro unlocks the remaining 17 scrims, which is where the Vercel AI SDK itself appears: structured outputs, tool calling, the routing agent, web search, and the finished app. Pro also unlocks the Certificate of Completion listed at the bottom of the table of contents and the Pro-only Discord channels. Scrimba's pricing page lists basic Discord access as free, so the server alone is not a reason to upgrade. See [current plans](https://scrimba.com/our-pricing?via=u42d4986) for what a subscription includes. ## How long it takes 114 minutes is video runtime. Plan for five to eight hours. The first hour goes on accounts and keys: an OpenAI key with billing enabled, a Supabase project, two SQL snippets pasted into the Supabase editor, and three environment variables in the scrim settings. Each of the six challenges takes 10 to 25 minutes if you attempt it before watching the solution. The basics and routing challenges are the quick ones; the structured outputs, tool-calling, and web-search challenges have two or three parts each. If you take Mayo's stretch goal seriously and swap in your own documents, add another few hours. Two or three evenings is realistic. ## Who it's for, and who should skip it It fits JavaScript developers who already understand what RAG and function calling do and want to see them wired together with a current SDK, in a form they can lift into a real project. It is also a good first look at OpenAI's built-in web search tool, which most agent courses skip. Skip it, for now, if you have not built anything with an LLM API. Do [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) first, then [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/), which teaches the tool-calling loop from scratch. Skip it if you need a framework other than the Vercel AI SDK, or a provider other than OpenAI; nothing here is portable without rewriting the imports. And skip it if you were hoping for a frontend: the chat UI is a static HTML page with no React in it. [Preview Build a Support Agent with Vercel AI SDK](https://scrimba.com/build-a-support-agent-with-vercel-ai-sdk-c0lk05ahir?via=u42d4986) ## Prerequisites Mayo's own list from the intro: the OpenAI API and how to get a key, basic prompting, the concept of retrieval augmented generation, function calling, and a basic Express server for API routes. Scrimba's course page adds "ideally" APIs, Node tooling, and SQL. In practice you also need to be comfortable with `async`/`await`, ES module imports, and reading a Zod schema. You will need an OpenAI API key with some credit and a free Supabase account; both are set up on screen in the first four scrims. ## Where it fits Scrimba's course page lists this under the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/). The natural order is [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) for the embeddings and vector store side, [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) for the tool-calling loop, then this course to see both combined on the Vercel AI SDK. [Build Serverless AI Agents with Langbase](https://scrimbaguide.tech/docs/courses/ai/serverless-ai-agents-with-langbase/) is the contrasting build with a different toolkit, and [Intro to Model Context Protocol](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/) is where tools go next. If the Express part was unfamiliar, [Learn Express.js](https://scrimbaguide.tech/docs/courses/javascript/expressjs/) covers it. ## Strengths and limits What it does well. It is short and ends with a working, deployable agent. It teaches the current AI SDK v5 API rather than the older one. The routing lesson shows the classify-then-branch pattern in plain code before hiding it behind tools, which is the right order. And five of the six challenges are graded copies of the lesson before them, so they are doable without a hint; the sixth, the routing refactor, is the one that asks you to combine two lessons. Where it is limited. It depends on two external accounts and a paid API key. It is OpenAI-only, and text splitting is demonstrated once and then dropped. The final UI is minimal, and nothing is said about evaluating whether the agent's answers are any good. The web search lesson is also already dated (it names GPT-5 as the newest model), which is inevitable but worth knowing. ## Related courses and comparisons - [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/), the conceptual prerequisite - [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/), the embeddings and retrieval side in more depth - [Build Serverless AI Agents with Langbase](https://scrimbaguide.tech/docs/courses/ai/serverless-ai-agents-with-langbase/), a contrasting (and free) agent build - [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/), the underlying fundamentals - [Intro to Model Context Protocol (MCP)](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/), the next step for tools - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/), the path this course belongs to **Q: Is Build a Support Agent with Vercel AI SDK free?** Partly. The first six scrims (32 minutes, through the first retrieval challenge) are free previews marked SAMPLE. The remaining 17 scrims, including everything about the Vercel AI SDK itself, need Scrimba Pro. **Q: What do you build?** A customer support chatbot trained on nine of Scrimba's help center articles. The docs are embedded into a Supabase pgvector table, and the agent uses generateText with two tools, a knowledge base search and OpenAI's web search, plus stopWhen to decide how to answer each question. The final lesson serves it from an Express route with a plain HTML page. **Q: Which version of the Vercel AI SDK does it teach?** AI SDK v5. The package.json pins ai 5.0.x and @ai-sdk/openai 2.0.x, and the code uses inputSchema, stopWhen, and stepCountIs, with zod 4 for schemas. The models are gpt-4o and gpt-4o-mini plus text-embedding-3-small. **Q: Do I need my own API keys?** Yes. You need an OpenAI API key and a free Supabase project, and you save OPENAI_API_KEY, SUPABASE_URL, and SUPABASE_SERVICE_ROLE_KEY in the scrim's environment settings. The setup is shown on screen in the first four scrims. **Q: Who teaches it?** Mayo Oshin, who introduces himself as an AI engineering educator and coauthor of the O'Reilly book Learning LangChain. He narrates every lesson; the three short platform add-ons at the end are voiced by Scrimba staff. **Q: How long does it take?** 114 minutes of video. With account setup and the six challenges, plan for five to eight hours, or two to three evenings. **Q: Are there challenges?** Six of the 23 scrims are challenges, one after each main lesson: vector retrieval, AI SDK basics (a recipe you generate and then embed), structured outputs (a sandwich order schema and a message classifier), tool calling (a grocery price lookup), agentic routing (refactor the classifier to generateObject), and web search retrieval. All six carry Scrimba's Challenge with Instant Feedback icon. **Q: Does it have transcripts or subtitles?** Yes. Every scrim has captions, a timestamped transcript under the settings menu, and subtitles in ten languages. ### Related Guides - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) - [Scrimba AI Courses](https://scrimbaguide.tech/docs/courses/ai/) - [Build Serverless AI Agents with Langbase](https://scrimbaguide.tech/docs/courses/ai/serverless-ai-agents-with-langbase/) --- # Learn AI Agents Source: https://scrimbaguide.tech/docs/courses/ai/ai-agents/ Learn AI Agents is Bob Ziroll's Pro course on LLM agents: 31 scrims, just under two hours, where you build the same weather-and-location agent twice, first with a hand-written ReAct loop, then with OpenAI function calling. The loop logic holds up; the SDK and the models it runs on are late 2023. Reviewed inside the course with a Pro account, September 2026. This page is part of our [Scrimba AI courses](https://scrimbaguide.tech/docs/courses/ai/) catalog. Scrimba's course page lists it under the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/). ## Quick answer It fits developers who already call an LLM from JavaScript and want to see what an agent loop is actually doing, not which framework to install. The catch: the code is frozen in November 2023, down to a beta OpenAI helper Bob warns might change "in one or two days." Take [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) first if you have not, then move on to [Build a Support Agent with Vercel AI SDK](https://scrimbaguide.tech/docs/courses/ai/a-support-agent-with-vercel-ai-sdk/) or [Build Serverless AI Agents with Langbase](https://scrimbaguide.tech/docs/courses/ai/serverless-ai-agents-with-langbase/) for a current stack. **Learn AI Agents** Build an LLM agent from scratch with a ReAct prompt and a loop, then rebuild it with OpenAI function calling. - Duration: 2.0 hrs - Level: Intermediate - 31 lessons - Taught by [Bob Ziroll](https://scrimba.com/@bobziroll?via=u42d4986) [View on Scrimba](https://scrimba.com/learn-ai-agents-c034?via=u42d4986) ## Is it worth your time? The thing this course does that most agent tutorials skip is make you build the loop by hand before any SDK does it for you. Bob is explicit about why. In lesson 6 he says the LLM "will tell us what function it wants to call or what action it wants to perform, and then we will write our code in a way that can then actually perform that action." You then spend nine scrims doing exactly that. You write the system prompt, split the model's reply into lines, find the `Action:` line with a regular expression, look the function up in an `availableFunctions` object, push an `Observation:` message back, and wrap it all in a `for` loop capped at five iterations. When the OpenAI function calling section replaces all of it with a `tool_calls` array and a `finish_reason` check, you understand what the API is saving you from. That is the point of the course and it lands. By the end you can write a tool-calling loop from nothing and read an OpenAI `tool_calls` response; you will not have a product, since the weather tool stays hardcoded the whole way through. The code has aged. The dependency panel shows an `openai` 4.1x SDK throughout (`openai@4.14.2` in the ReAct scrims, `openai@4.19.1` by the UI scrim). The models are `gpt-4`, `gpt-3.5-turbo`, `gpt-3.5-turbo-1106` and `gpt-4-1106-preview`, and in the setup challenge Bob says the 1106 models were "just released" at the time of recording. That puts it in November 2023. The final technique, `openai.beta.chat.completions.runFunctions`, is introduced with the words "this is so new that not only is it still considered in beta with OpenAI's SDK, but it's also not even in their documentation." Bob warns you in the same scrim that "what we just learned here might be changing for all I know in one or two days." He was right. Treat the concepts as current and the exact method names as history you will need to translate. The second caveat is scope. `getCurrentWeather` returns a hardcoded forecast for the whole course, and Bob edits the numbers by hand to show the answers change. `getLocation` starts hardcoded too, then in the "Adding arguments" scrim becomes a real call to an IP lookup service, which Bob demonstrates by switching his VPN between Salt Lake City, New York and Denver. That is the only real tool in the course. There is no weather API and no framework, so you finish with a pattern, not a product. ## What you'll learn Scrimba presents this course as one flat list of 31 scrims with no module headers. The grouping below is mine, by topic, so the durations can be compared. ### Course curriculum 31 scrims in a flat list, grouped by topic for this review - Module 1: Intro and prompt engineering recap (18 min, 5 lessons) - Module 2: ReAct agent from scratch (47 min, 11 lessons) - Module 3: OpenAI functions agent (41 min, 9 lessons) - Module 4: UI, solo project and wrap-up (15 min, 6 lessons) Lesson counts are the `toc-scrim-item` rows I counted in the expanded table of contents in September 2026, and the durations are the per-scrim times added up. My sum is 121 minutes against the 117 minutes in the page header and the `PT1H57M12S` in its structured data. One wrap-up scrim is listed at 3:11 but its transcript ends at 1:15, which accounts for about half the gap. Scrimba's own listing and structured data say 31 lessons, so on this course the numbers agree. ## Inside the course, scrim by scrim ### 1. Intro and prompt engineering recap (18 min, 5 scrims) All five of these are marked SAMPLE, so you can watch them without Pro. "AI Agent Intro" gives the definition above, with adaptive cruise control and self-driving cars as the analogy, and sets the plan: "first, using a prompting strategy called ReAct, then refactoring our code to use a built in capability of OpenAI called functions, and by the end we'll get a sneak peek of something that's currently in beta called automatic function calling." "Prompt Engineering 101" is a six minute compression of Scrimba's separate [Prompt Engineering for Web Developers](https://scrimbaguide.tech/docs/courses/ai/prompt-engineering-for-web-developers/) course. Bob recommends you take at least its first section before this one. The demo is the old centering-a-div question run three ways in the OpenAI Playground on GPT-3.5, from "how do I center something" to "how do I center a div element horizontally and vertically using CSS Flexbox." The point is that the vague prompt gets a scattershot answer covering Photoshop and word processors, and the specific one gets code you could paste. "Control Response Formats" is two minutes on asking for a length ("explain in two paragraphs", "give me twenty examples") or a shape (a comparison table, an analogy, a comment above every line of pasted code). "Zooming Out" is a three minute diagram scrim. Bob draws agents as one small region inside AI, with LLMs like GPT-4, Mistral and Llama 2 as tools an agent can pick up, alongside speech, vision and image models. His one-line definition here is worth keeping: an agent "can pull together multiple tools and then iterate on a task using those tools until that task is complete." "Agent Setup" writes the first `chat.completions.create` call with `gpt-4` and a single user message asking for activity ideas based on location and weather. The model, of course, answers that it cannot access either, which is the problem the rest of the course solves. This scrim is also where Bob tells you to put your own key in an `OPENAI_API_KEY` environment variable on Scrimba: "Without an API key, you'll still be able to see my recordings and the data that I get back from my API calls, but you won't be able to play with the code." ### 2. ReAct agent from scratch (47 min, 11 scrims) ![Slide from Scrimba's Learn AI Agents course: a ReAct flowchart of think, call a function, observe, then answer or loop.](https://scrimbaguide.tech/img/scrimba/learn-ai-agents/react-loop-flowchart-title-card.webp) *Nine numbered parts turn this reason-act-observe flowchart into a hand-written loop with regex parsing and a five-iteration cap.* The core of the course. "Introduction to ReAct prompting" argues against hardcoding a chain (call the weather function, pass the result into the prompt) because, as Bob puts it, "I've predetermined in the code a chain of events that need to occur in order to get a very specific response." Instead the LLM gets three phases, reasoning, acting and observing, and the flowchart in the grid above. ReAct is short for reason and act; Bob links a Medium article for the theory and moves on. "Build action functions" creates `tools.js` with two async stubs. `getLocation` returns "Salt Lake City, Utah" (Bob's real location; by part 7 he has changed it to New York City) and `getCurrentWeather` returns a JSON string with 72 degrees and sunny. Bob first wires them into the prompt the naive way, as a chain, and gets a working answer. Then he says the sentence that starts the real work: "Let's refactor this so that we turn our manual chain of events into an agent that is aware of the tools at its disposal and able to reason, act, and observe." The build is a numbered run of nine "ReAct Agent" parts. Part 1 writes a four step plan as a comment in `index.js`: design the ReAct prompt, build a loop, parse actions, create an end condition. It is also where Bob switches from `gpt-4` to `gpt-3.5-turbo` because a loop that calls the API five times per question adds up. Part 2 pastes in the system prompt, which he credits to a blog post with a Python implementation of the pattern. The prompt spells out `Thought`, `Action`, `PAUSE` and `Observation`, lists the two available actions with an example call for each, and ends with a full example session as a few-shot demonstration (a worked example the model is expected to imitate). Part 3 is a slide scrim about state. Bob's point is that "between one API call and the next, it's not remembering our conversation," so the loop has to resend the whole `messages` array every time. He draws the model with open eyes when it is reading the history and closed eyes while your code runs the action. Part 4 is the first challenge: stub an `agent(query)` function, build the `messages` array with the system prompt and the query, move the API call inside, and call it. Bob tests it with "What book should I read next? I like self help books" and the model, with only two tools, tries to look up his location anyway. Parts 5 to 7 are the parsing. Part 5 notices that the model separates its lines with newline characters and writes the plan: split on `\n`, find the line with `Action:`, pull out the function name and argument, call it, add an `Observation:` message. Part 6 is a challenge with the regex supplied; the solution uses `Array.find` with `regex.test`, then `regex.exec` to read the two capturing groups. Part 7 is another challenge, and the answer is bracket notation: put both functions in an `availableFunctions` object and call `availableFunctions[action](actionArg)`. ![Learn AI Agents, ReAct Agent part 7: code editor and console panel showing the parsed function call.](https://scrimbaguide.tech/img/scrimba/learn-ai-agents/react-agent-calling-the-function-lesson.webp) *By 4:04, Part 7's regex has pulled getLocation and null out of the model's text, and availableFunctions[action](actionArg) is about to call the stub with them.* Screenshot of scrimba.com, taken by scrimbaguide.tech. The challenges are real pauses: "So I'll give you a chance now to pause and work on this challenge," then the solution. Bob is candid that this is not glamorous work. At the end of part 7: "the way that we're parsing these strings does feel a bit tedious. This is going to lead us very soon into learning about OpenAI functions and we'll see how we can offload what kind of feels like a hacky way around figuring out what function to call to OpenAI." Part 8, "Housekeeping", hoists `messages` out of the call so it can be pushed to, adds the assistant reply and the `Observation:` line to it, and throws an "unknown action" error if the model names a function that is not in the object. Part 9 is the payoff and the longest scrim in this half at 7:38. Bob caps the loop with `MAX_ITERATIONS = 5` ("we don't know for certain if it's not just going to get completely out of control and end up calling the API a thousand times"). He adds a console log per iteration and hits two bugs on camera: `message.push` instead of `messages.push` ("I'm sorry for anybody that was screaming at me for that") and a missing `await`. Then comes the three-iteration run below, and a last test where he edits the hardcoded weather to two degrees and snow and the suggestions switch to ice skating at Rockefeller Center. ![Learn AI Agents, ReAct Agent part 9: the console lists each loop iteration next to the code editor.](https://scrimbaguide.tech/img/scrimba/learn-ai-agents/react-agent-loop-iterations-lesson.webp) *ReAct Agent Part 9 at 4:40. Iteration 2 calls getCurrentWeather with the city iteration 1 just found, iteration 3 answers: the whole ReAct loop in one console.* Screenshot of scrimba.com, taken by scrimbaguide.tech. ### 3. OpenAI functions agent (41 min, 9 scrims) ![Slide from Scrimba's Learn AI Agents course titled OpenAI Functions, showing a screenshot of OpenAI's function calling documentation page](https://scrimbaguide.tech/img/scrimba/learn-ai-agents/openai-functions-title-card.webp) *The hand-written loop gets rebuilt with a tools schema, a finish_reason check, and the beta runFunctions helper.* Slides from scrimba.com. Function calling is OpenAI's built-in version of what you just hand-rolled: you describe your functions in the request, and the model replies with a structured `tool_calls` array instead of prose. Bob's framing in the one minute intro: "we don't have to do the same kind of string parsing that we were doing before. I could be wrong but it feels like this is going to be quite a bit more error prone than something that's built into OpenAI." The plan is to "gut everything that we've done here and rewrite it from scratch using OpenAI functions," pulling from OpenAI's documentation example. "Demo day" is demolition, not a demo. Bob deletes the long ReAct prompt and the regex, replaces the system message with two lines ("You are a helpful AI agent. Give highly specific answers based on the information you're provided"), and adds an empty `tools: []` to the request so the code still runs. "Tools" (6:28) fills that array in. Each entry is `{ type: "function", function: { name, description, parameters } }`, where `parameters` is a JSON schema, a small object that names each argument and its type. Bob moves the 25-line array into `tools.js`, and shows the two things that matter: with a location question the response has `content: null` and a `tool_calls` array; with "how are you today?" it has content and no tool calls. "Loop Logic" writes the plan around `finish_reason`: if it is `"stop"`, return the content; if it is `"tool_calls"`, call the functions, push the results and loop again. "Setup Challenge" has you write the `stop` branch; Bob's solution destructures `finish_reason` and `message` from `choices[0]`. This is also where he swaps to `gpt-3.5-turbo-1106` and explains that "at the time of recording, this was just released as well as a GPT four dash eleven o six preview model," adding that 1106 "just means November sixth." "Tool Calls" is the other challenge: the `tool_calls` branch. The note that matters is that `tool_calls` is an array, because "in a very recent update" the API changed from a single `function_call` to a list. Bob loops it with `for...of`, and tests "get me the weather in Tokyo and New York" and then Oslo too; the model calls the stub three times. "Pushing to messages" adds the results with `role: "tool"`, a `tool_call_id` and the function name, and hits an API error on camera: a tool message "must be a response to a preceding message with tool_calls." The fix is one line, pushing the assistant's own message first, and he explains why the ID exists (to match each result to its call when the same function runs three times). "Adding arguments" gives `getCurrentWeather` a `location` parameter, adds it to the schema with a `required` list, and reads it with `JSON.parse(toolCall.function.arguments)`. Bob also tries a `unit` enum, gets 75 degrees Celsius back for every city, and removes it. Then he replaces the `getLocation` stub with a real IP lookup and shows it working through a VPN. "Automatic function calls" (9:04, the longest scrim in the course) deletes the loop entirely in favor of `openai.beta.chat.completions.runFunctions`, passes the real JavaScript functions instead of schemas, and reads the result with `await runner.finalContent()`. A `.on("message", ...)` listener shows the internal system, user, assistant and function messages flowing past. Bob's reaction to seeing his own loop absorbed into the SDK: "I'm not sure whether to rejoice or to cry." ### 4. UI, solo project and wrap-up (15 min, 6 scrims) "Adding UI to agent" is the sixth challenge and the only scrim with a visible front end: a vanilla JavaScript chat window with a form, a `renderNewMessage` helper in `dom.js`, and `gpt-4-1106-preview` behind it. The challenge is to make the agent remember the conversation. That sounds like one `messages.push` and turns out to need the array hoisted out of the function so it survives between submissions. Bob asks "please suggest some outdoor activities" as a follow-up and judges the answer honestly: "They're not specific to my location of Salt Lake City at all. But for a first go at it, that's not too shabby." ![Learn AI Agents, Adding UI lesson: a chat window preview beside the code editor showing the agent's reply.](https://scrimbaguide.tech/img/scrimba/learn-ai-agents/agent-chat-ui-proof-of-concept-lesson.webp) *At 3:20 of Adding UI to agent, the dependency panel reads openai@4.19.1, up from the 4.14.2 shown in the two ReAct screenshots earlier in this review.* Screenshot of scrimba.com, taken by scrimbaguide.tech. The Solo Project brief, "AI Travel Agent," is narrated by a different Scrimba voice than Bob's and comes with a Figma file. The app is a form for travelers, origin, destination, dates and budget, then a results page with dates, weather, flights and a hotel. The brief is explicit that "you can just use the OpenAI API to create hallucinated flight and hotel data," booking buttons only `console.log`, and the one real integration is a weather API. Stretch goals include activity ideas that differ for a single traveler, a couple or a family, a shareable trip page, and AI-generated images. "Nice work!" recaps in a little over a minute. Bob's own summary of the ReAct half is the best short description of it: "some fancy prompt engineering that we did on top of a custom loop that we built around our GPT assistant." Three housekeeping scrims follow, voiced by other Scrimba staff: Scrimba Docs, the Scrimbassador referral program, and how to use the certificate. ## What a lesson feels like Scrims run from under a minute to nine, most between three and six. Every one is Bob's voice over a live editor with the console open below and the preview collapsed, since nothing here has a UI until the last build. The slides are few and used for diagrams, not bullet points. Challenges arrive as a numbered comment block in `index.js` ("CHALLENGE: 4. Calling the function, 5. Add an Observation message") plus a spoken pause; the six marked in the table of contents each get a "Challenge" badge on hover. Bob also says more than once that you can skip a challenge and watch, and that asking ChatGPT for help with the regex is fair game. You need your own OpenAI key in a Scrimba environment variable to run anything, and every run costs money on your account, which Bob mentions when he caps the loop. Without a key you can still watch and read the code. All scrims have captions, a timestamped transcript under the settings menu, and subtitles in ten languages per the course header. Bob's manner is dry and self-aware. When the SDK update makes his loop redundant he says "let's just rip the band aid right off," and he ends with an unprompted speech about how quickly things change and why you should check the GitHub README rather than trust the course. ## Free or Pro: exactly what is gated This is a Pro course. Scrimba's catalog lists it under the Pro tab and its structured data says `isAccessibleForFree: false`. The first five scrims (the intro, both prompt engineering scrims, "Zooming Out" and "Agent Setup") carry the SAMPLE badge and play without a subscription. Everything from "Introduction to ReAct prompting" onward, including all six challenges, the AI Travel Agent solo project, and the certificate of completion, needs Pro. See [current plans](https://scrimba.com/our-pricing?via=u42d4986) for what a subscription costs in your region. Scrimba's pricing page lists basic Discord access as free and the Pro-only channels as Pro, so the community itself is not the reason to upgrade; this course and the rest of the AI Engineer Path are. ## How long it takes 117 minutes of video, but the course expects you to type. Plan for four to six hours. That covers the runtime and the six challenges, each a few minutes of real coding if you do them before watching the solution. It also covers the setup cost of an API key and environment variable, and the time you will spend reconciling `runFunctions` and the 1106 models with whatever the OpenAI SDK looks like when you take it. The AI Travel Agent solo project is separate and open-ended; from the brief and the Figma file I would budget a further six to ten hours for a working version. ## Who it's for, and who should skip it It fits you if you have already called an LLM from JavaScript, you know what `async`/`await` and array destructuring are, and you want to understand what agent frameworks are doing rather than which one to install. Bob says as much in the setup scrim: "I'm assuming that this is not your first course that you're taking in the AI engineer path." Skip it, for now, if you have not done [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) or something equivalent; the course moves fast through the OpenAI client and never explains it. Skip it if you need Python; everything here is browser JavaScript. Skip it if you want a current, production-shaped agent stack: the models and the beta helper are late 2023, and the [Vercel AI SDK support agent](https://scrimbaguide.tech/docs/courses/ai/a-support-agent-with-vercel-ai-sdk/) or [Langbase](https://scrimbaguide.tech/docs/courses/ai/serverless-ai-agents-with-langbase/) courses are the applied follow-ups. [View Learn AI Agents on Scrimba](https://scrimba.com/learn-ai-agents-c034?via=u42d4986) ## Prerequisites Comfortable JavaScript (destructuring, regex basics, `async`/`await`, ES modules), a working knowledge of the OpenAI chat completions API, an OpenAI account with an API key and a little credit on it, and Scrimba's environment variable feature (the setup scrim links to a post explaining it). Prompt engineering basics help; the course's two recap scrims assume you have seen them before. ## Where it fits It sits in the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/). The natural order on this site is [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) first, then this course to understand the loop, then one of the tooling-specific agent courses to build something real. The [Model Context Protocol](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/) course is the closest conceptual neighbor, since MCP standardizes the "tools" this course hand-rolls, and [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) covers the retrieval step an agent would call as one of those tools. ## Strengths and limits What it does well: it builds the agent loop by hand before automating it, so the `tool_calls` API makes sense when it arrives; the challenges are placed where the work is (parsing, calling, the stop condition); Bob debugs on camera and says when something is hacky; and at under two hours it does not pad. Where it is limited: the code is late 2023 (an `openai` 4.x SDK, `gpt-3.5-turbo-1106`, a beta `runFunctions` helper that Bob himself warns may vanish). The weather tool is a hardcoded stub and the location tool is a bare IP lookup, and there is no error handling beyond one thrown error, no streaming, and no framework. The solo project asks for a full front end the course never taught, so the jump from the last scrim to the brief is a big one. ## Related courses and comparisons - [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/), the prerequisite fundamentals - [Prompt Engineering for Web Developers](https://scrimbaguide.tech/docs/courses/ai/prompt-engineering-for-web-developers/), the course Bob's recap scrims summarize - [Build Serverless AI Agents with Langbase](https://scrimbaguide.tech/docs/courses/ai/serverless-ai-agents-with-langbase/), a free, applied companion - [Build a Support Agent with Vercel AI SDK](https://scrimbaguide.tech/docs/courses/ai/a-support-agent-with-vercel-ai-sdk/), a project-based agent build on a current SDK - [Intro to Model Context Protocol (MCP)](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/), the standard for the tools this course hand-writes - [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/), to ground an agent's answers in your data - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/), the path this course sits in **Q: Is Learn AI Agents free on Scrimba?** No. It is a Pro course. The first five scrims (intro, two prompt engineering recaps, Zooming Out, and Agent Setup) are free samples; the ReAct build, the OpenAI functions build, all six challenges, the AI Travel Agent solo project and the certificate need a Pro subscription. **Q: Who teaches it?** Bob Ziroll, per the teacher card on the course page and his own introduction in the first scrim. He also teaches Scrimba's Learn React and Advanced React. The solo project brief and the three housekeeping scrims at the end are voiced by other Scrimba staff. **Q: What do you build?** One agent, twice. A weather-and-location agent with two tools (getLocation and getCurrentWeather), first driven by a hand-written ReAct system prompt and a parsing loop, then rebuilt with OpenAI function calling and the SDK's beta runFunctions helper. The weather tool stays hardcoded; the location tool becomes a real IP lookup in the Adding arguments scrim. The last scrim wraps it in a vanilla JavaScript chat UI. The solo project is an AI travel agent built from a Figma design. **Q: Do I need an OpenAI API key?** Yes, to run any of the code. The Agent Setup scrim tells you to create one and store it as an OPENAI_API_KEY environment variable on Scrimba. Without it you can watch the recordings and read the code but not run or edit it. Each run bills your OpenAI account. **Q: Is the course up to date?** The concepts are; the code is not. The dependency panel shows an openai 4.1x SDK (4.14.2 in the ReAct scrims, 4.19.1 by the UI scrim), the models are gpt-4, gpt-3.5-turbo-1106 and gpt-4-1106-preview, and the final technique is a beta runFunctions helper Bob describes as not yet documented. He says the 1106 models had just been released when he recorded, which dates it to November 2023. Expect to translate method names to the current SDK. **Q: Are there challenges, and are they AI-graded?** Six scrims carry a Challenge badge in the table of contents: ReAct code setup, parsing the action, calling the function, the OpenAI functions setup challenge, tool calls, and adding UI. They are pause-and-code exercises with Bob's solution afterwards. I did not see the instant AI feedback badges that some newer Scrimba courses use. **Q: How long does it take?** 117 minutes of video by Scrimba's count (121 by my sum of the scrim times). Budget four to six hours with the challenges, key setup and some SDK translation, plus six to ten more if you build the AI Travel Agent solo project. **Q: Does it use Python or a framework like LangChain?** Neither. It is browser JavaScript with the official openai package and nothing else. No LangChain, no Vercel AI SDK, no Python. **Q: Does the course have transcripts or subtitles?** Yes. Every scrim has captions, a timestamped transcript under the settings menu, and the course header lists subtitles in ten languages. ### Related Guides - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) - [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) - [Scrimba AI Engineer Path Guide](https://scrimbaguide.tech/blog/scrimba-ai-engineer-path-guide/) --- # Intro to AI Engineering Source: https://scrimbaguide.tech/docs/courses/ai/ai-engineering/ Scrimba's core Pro course on building software around large language models, taught by Arsala Khan in about 2.5 hours across 36 scrims. It's a build-along: you take Gift Genie, a gift-suggestion app, from a first API call to a streaming, tool-using, backend-secured product, and it's the foundation course on Scrimba's AI track. Reviewed inside the course with a Pro account, September 2026. ## Quick answer Intro to AI Engineering suits developers with working JavaScript who want to build real LLM features rather than a playground demo: you leave knowing the messages array, streaming, structured output, and how to keep an API key off the client. The catch is the prerequisite, it assumes JavaScript and a model-provider account and doesn't reteach either. It's sequenced first into the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/); if you're new to programming, start with [Learn to Code with AI](https://scrimbaguide.tech/docs/courses/ai/to-code-with-ai/) instead. **Intro to AI Engineering** Build Gift Genie, an LLM-powered app, from a first API call to streaming, structured output, web search, and a secured Node backend. - Duration: 2.5 hrs - Level: Intermediate - 58 lessons - Taught by [Arsala Khan](https://scrimba.com/@ArsalaBangash?via=u42d4986) [View on Scrimba](https://scrimba.com/intro-to-ai-engineering-c032?via=u42d4986) ## Is it worth your time? If you are going to take the AI Engineer Path, yes, and take it first. It is short and dense, and it spends its time on the part most tutorials skip: what happens between "the model answered" and "the feature is reliable." Error handling, sanitizing model output before it hits the DOM, streaming chunks into the UI, forcing JSON, and getting the API key off the client each get their own scrims, in that order, because each one is a real failure you would otherwise hit in production. Arsala's framing in the first scrim is the right one: "this course isn't about chasing trends, it's about learning how to build with these tools responsibly, same way we think about our APIs interacting with our application code." He also promises not to say "AI superpower" again ("Probably.") and then does, which tells you the tone. It assumes working JavaScript and the ability to call an API, and it does not reteach either. And it needs a model-provider account: OpenAI is "the safest default" but requires a small minimum credit purchase, which Arsala says comfortably covers the whole path; Groq and OpenRouter are offered as free alternatives, and an `api-urls.txt` file in the setup scrim lists the endpoints. ## What you'll learn The course is one flat list of 36 scrims rather than modules; the grouping below is mine, by topic and in order. ### Course structure 36 scrims in 9 editorial groups - Module 1: Orientation: marketplace, environment, client (free samples) (19 min, 5 lessons) - Module 2: First requests: prompts, tokens, snapshots (22 min, 7 lessons) - Module 3: Messages, system prompt, UI, errors, safe markdown (30 min, 6 lessons) - Module 4: Streaming into the Gift Genie UI (15 min, 3 lessons) - Module 5: Context, few-shot prompting, temperature and top-p (12 min, 3 lessons) - Module 6: Responses API, JSON and structured outputs (12 min, 3 lessons) - Module 7: Web search tool (10 min, 2 lessons) - Module 8: Backend orientation and migration super challenge (15 min, 2 lessons) - Module 9: Outro, PollyGlot solo project, certificate (10 min, 5 lessons) Group durations are my estimates from the per-scrim times shown in the table of contents; the course total is Scrimba's 2.5 hours. Scrimba's listing says 58 lessons, which counts clips inside scrims; the table of contents you click through has 36. For the theory in written form, Scrimba's free [How AI Works handbook](https://docs.scrimba.com/how-ai-works/introduction?via=u42d4986) covers the same fundamentals (tokens, prompting, context, calling models) with a Beginner, Intermediate, and Deep Dive depth switcher. The handbook explains the concepts; this course wires them together in JavaScript. ## Inside the course, scrim by scrim ### Orientation (5 scrims, all free to preview) "Introducing Your AI Superpower" makes the case with the Gift Genie itself: the old way to build a gift recommender was "a massive curated database of products," a search engine, a ranking system, and "endless rules for different demographics of people"; now you describe the person in natural language. "The AI Marketplace" is the most useful five minutes in the course for a newcomer: models are named `organization/model` like git repos, a model provider is "a company that runs models on their servers and provides an API," and the OpenAI JavaScript library "is not locked to the OpenAI platform" because Groq, OpenRouter and others host OpenAI-compatible APIs. "Environment Setup" walks through creating a key and storing three environment variables in Scrimba's editor (settings → edit environment variables): `AI_URL`, `AI_KEY`, and `AI_MODEL`, with the model ID kept in an env var so that "switching providers will mostly mean changing these three values, not touching your code." "Recommended Models" and "Setting Up Your AI Client" finish the setup. ### First requests (7 scrims) Your first request, a walkthrough, and a "Rebuilding" challenge, then `max_tokens` ("Shorter Responses With Tokens"), refining the prompt, refactoring the request, and a short scrim on model snapshots (why `gpt-x-2024-xx-xx` style pinned versions exist). ### Messages, system prompt, UI, errors, safe markdown (6 scrims) The messages array and the system message are the conceptual core; an aside on token costs and context windows explains why conversation length matters. "Wiring up our UI" connects the request to the Gift Genie form, "Error Handling" deals with failed calls, and "Rendering Markdown Safely" introduces `marked` plus `DOMPurify` so model output cannot inject HTML. That pairing (`import { marked } from "marked"; import DOMPurify from "dompurify"`) is the first thing you see at the top of `index.js` in the later challenges. ### Streaming (3 scrims) "Streaming AI Responses" is taught in the console first: set `stream: true`, then loop with `for await` because "a normal loop expects everything to be there already," and read `choices[0].delta.content` instead of `message.content`. The "Gift Genie UI Streaming Challenge" has you reconstruct the message in the page, and "Structuring Our Markdown Responses" cleans up what streams in. ### Context, prompting, and sampling (3 scrims) Making the Gift Genie context aware (carrying prior turns), few-shot prompting with examples in the system prompt, and temperature and top-p. ### Responses API, JSON, structured outputs (3 scrims) A short intro to OpenAI's Responses API, then forcing JSON output, then structured outputs with a schema so the UI can render fields rather than prose. ### Web search tool (2 scrims) An aside on the web search tool and then "Web Search In The Gift Genie UI," so suggestions can reference current products. ### Backend orientation and the super challenge (2 scrims) The course's real ending. "Backend Orientation" explains why the key cannot live in the browser, and the "Backend Migration Super Challenge" (about nine minutes of brief) has you move the call to a Node server: the front end sends a plain `fetch` with the prompt, the server owns the messages array and the OpenAI call, returns JSON, and the client converts markdown and sanitizes it. The workspace is a real Vite project with `server.js`, `package.json`, `vite.config.js`, a `challenge.md`, and a `hints/` folder with twelve numbered hint files, running in Scrimba's terminal panel. ![Intro to AI Engineering, Backend Migration Challenge: a code editor and terminal run a full-stack app beside its live preview.](https://scrimbaguide.tech/img/scrimba/intro-to-ai-engineering/gift-genie-backend-migration-challenge.webp) *The Backend Migration Super Challenge workspace at 0:00, with the Vite front end and Node server both live in Scrimba's Runner panel and the Gift Genie UI on the right waiting for a prompt.* Screenshot of scrimba.com, taken by scrimbaguide.tech. ### Outro and solo project (5 scrims) An outro, then "Solo Project: PollyGlot," a translation app briefed by Per Borgen: type English text, pick a language, guess the translation yourself, then press the button. You get a blank CSS file, a blank JavaScript file, and a near-empty HTML file, and build the rest, including the API call, from scratch. The remaining scrims are a Scrimba Docs pointer, an affiliate-program note, and "How to Utilize Your Certificate." ## What a lesson feels like Scrims run one to seven minutes. Arsala explains with slides and diagrams (request "shape," the frontend-server-provider flow), then switches to the editor and runs the code so you see the console output. Challenges are written into files as comments or as a `challenge.md`, and the recording pauses. The AI calls are live: when Arsala streams a response in the console, you can see the chunks arrive. Every scrim has captions, a timestamped transcript under the settings menu, subtitles in ten languages, and playback speed. Because the app talks to a real provider, your own runs cost real (tiny) money on OpenAI or free-tier quota on Groq and OpenRouter. Arsala says he "built this course, making a lot of API calls" without exhausting the minimum OpenAI credit. ## Free or Pro: exactly what is gated The first five scrims (through "Setting Up Your AI Client") are free samples. Everything from "Your First AI Request" onward, the streaming and backend challenges, and the PollyGlot solo project need Pro. Pro also covers the whole [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/), certificates, unlimited challenges, and the Pro Discord channels. See [current plans](https://scrimba.com/our-pricing?via=u42d4986) for what Pro costs in your region. ## How long it takes 2.5 hours of video, but the challenges are substantial: budget 8 to 12 hours, plus a couple of hours for provider sign-up and the environment variables the first time. The backend super challenge alone is a two to three hour session if you use the hints sparingly, and PollyGlot is another three to five hours built properly. ## Who it's for, and who should skip it It fits developers with JavaScript under their belt who want to build with LLMs and would rather understand the mechanics than copy snippets. It is the natural first technical stop on the AI track, and a good fit for people coming off [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/), whose Chef Claude project is a smaller version of exactly this. Skip it if you have never coded. Start with [Learn to Code with AI](https://scrimbaguide.tech/docs/courses/ai/to-code-with-ai/) or [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) first. Also skip it, for now, if you only want one specific technique like RAG; you can come here later. [Start Intro to AI Engineering on Scrimba](https://scrimba.com/intro-to-ai-engineering-c032?via=u42d4986) ## Prerequisites Working JavaScript: variables, functions, `async`/`await`, and calling an API with `fetch`. Basic familiarity with how web requests work helps. No prior AI experience is assumed. You will need an account with a model provider and an API key; the setup scrim covers OpenAI, Groq, and OpenRouter. ## Where it fits This is the backbone of the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/). Almost everything else on the AI track assumes the fundamentals taught here. Common next steps are [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/), [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/), and [Prompt Engineering for Web Developers](https://scrimbaguide.tech/docs/courses/ai/prompt-engineering-for-web-developers/). ## Strengths and limits What it does well: it is concise, it teaches the failure modes in the order you would meet them (errors, unsafe output, blocking UI, unstructured output, exposed keys), it is provider-agnostic with free options, and it ends with a real full-stack challenge and a solo project rather than a wrap-up slide. Where it is limited: it firmly assumes prior JavaScript, it needs a provider account before lesson six, the OpenAI-specific scrims (Responses API, structured outputs, web search) will age with that API, and the Scrimba page title still credits the course's previous instructor, which can confuse people comparing notes. ## Related courses and comparisons - [Learn to Code with AI](https://scrimbaguide.tech/docs/courses/ai/to-code-with-ai/), the free beginner on-ramp - [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/), to ground LLM output in your data - [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/), the agent follow-up - [Prompt Engineering for Web Developers](https://scrimbaguide.tech/docs/courses/ai/prompt-engineering-for-web-developers/), the productivity angle - [Learn React](https://scrimbaguide.tech/docs/courses/react/learn-react/), whose Chef Claude project is the gentler warm-up **Q: Is Intro to AI Engineering free?** The first five scrims (the AI marketplace, environment setup, recommended models, and setting up the client) are free samples. The rest of the course needs Scrimba Pro. The free starting points on the AI track are Learn to Code with AI and Intro to Mistral AI. **Q: Which AI provider do I need?** Any OpenAI-compatible one. Arsala recommends OpenAI as the default (it needs a small minimum credit purchase) and Groq or OpenRouter as free alternatives. The course stores the URL, key, and model in Scrimba environment variables so switching means changing three values. **Q: Do I need to know JavaScript first?** Effectively yes. The course assumes working JavaScript, async/await, and the ability to call an API. It does not reteach programming. **Q: Who teaches it?** Arsala Khan, who builds Scrimba's AI Engineer Path and also teaches Learn Context Engineering. Scrimba's page title still names the earlier instructor, Tom Chant, but the current recordings are Arsala's. **Q: Is this a project course?** Yes. You build Gift Genie throughout, from a first API call to streaming, structured output, web search, and a Node backend, and finish with a PollyGlot translation app as a solo project. **Q: How long does it take?** About 2.5 hours of video; plan for 8 to 12 hours with the challenges, more if you do the backend super challenge and PollyGlot properly. **Q: Where does it sit on the AI Engineer Path?** It is the foundation. Most other AI courses assume the concepts taught here, so it is usually the first technical course you take on the path. ### Related Guides - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) - [Prompt Engineering](https://scrimbaguide.tech/docs/courses/ai/prompt-engineering-for-web-developers/) - [Best AI Engineering Courses](https://scrimbaguide.tech/blog/best-ai-engineering-courses/) --- # Learn Context Engineering Source: https://scrimbaguide.tech/docs/courses/ai/context-engineering/ Arsala Khan's Learn Context Engineering is a one-hour Pro course built around a single chat app on the Vercel AI SDK and OpenRouter. You add a system prompt, then trim old messages by token count, then replace them with an AI-written summary so the app stops forgetting. It is small, focused, and worth the hour once your own app has hit the wall it demonstrates. Reviewed inside the course with a Pro account, September 2026. ## Quick answer This fits developers who already call a model from JavaScript and want to know why their chat app breaks once the conversation gets long. The catch: it assumes async/await and at least one live API call already under your belt, so total beginners will feel lost. Never called an LLM from code before? Start with [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) instead; the instructor also builds Scrimba's [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/), which this course slots into. **Learn Context Engineering** System prompts, token-based trimming, and AI summarization in one small chat app built with the Vercel AI SDK and OpenRouter. - Duration: 60 min - Level: Intermediate - 15 lessons - Taught by [Arsala Khan](https://scrimba.com/@ArsalaBangash?via=u42d4986) [View on Scrimba](https://scrimba.com/learn-context-engineering-c0u13jhi10?via=u42d4986) ![Learn Context Engineering, System Prompt Challenge slide: three chat windows show the same question in three tones.](https://scrimbaguide.tech/img/scrimba/learn-context-engineering/system-prompt-challenge-personas-slide.webp) *The System Prompt Challenge brief: the same model, three personas, three very different answers.* ![Learn Context Engineering, Summarizing Context Super Challenge slide: side-by-side chats show the AI forgetting, then recalling, a fact.](https://scrimbaguide.tech/img/scrimba/learn-context-engineering/summarizing-context-super-challenge-what-you-build-slide.webp) *The final challenge: before summarization the model has forgotten where you studied; after it, it remembers.* Slides from scrimba.com. ## Is it worth your time? Yes, if the problem is already real for you. Every AI chat demo works for five messages. The course is about what happens on message fifty. It shows the failure before the fix: in the Context Window Demo the app sends a preloaded debugging conversation to a model and gets back "your request does not fit within the model's context window." Then you fix it, twice, each time with a better method. The material is short and there is not much of it. Three ideas, one app, about an hour of video. That is the right size for the topic. Arsala does not pad it with theory, and the diagrams (a chat you scroll on your phone, a whiteboard that fills up) are the kind you remember. The caveat is that it is a Pro course that assumes a fair amount: JavaScript, async/await, and having sent a prompt to a model before. It also spends a few minutes on housekeeping that has nothing to do with context (a Scrimba Docs promo, a certificate scrim, an affiliate pitch). Fifteen scrims sounds like more than it is. ## What you'll learn Scrimba presents the course as one flat list with no modules. The four groups below are mine, made from the lesson titles and transcripts so the curriculum bar has something to show; the durations are the scrim lengths in each group added up. ### Course curriculum 15 scrims in 4 editorial groups, plus a Certificate of Completion entry - Module 1: System prompts (intro, setup, first challenge) (20 min, 5 lessons) - Module 2: The context window and trimming (15 min, 4 lessons) - Module 3: Summarizing context (24 min, 3 lessons) - Module 4: Outro, certificate, and Scrimbassador pitch (4 min, 3 lessons) I counted 15 scrims in the table of contents in September 2026, plus a Certificate of Completion entry. Scrimba's header says 59 minutes and its structured data says 13 lessons. The scrim lengths add up to about 63 minutes, and the two-lesson gap is most likely the Scrimba Docs promo and the Scrimbassador scrim, which are not lessons. When other pages on this site say 60 minutes or 13 lessons, that is Scrimba's number. ## Inside the course, scrim by scrim ### 1. System prompts (20 min, 5 scrims) The intro is under three minutes and names the problem in plain words: "after a long conversation, these AI assistants start to forget," as Arsala puts it in the first scrim. She lists the three techniques you will learn and assumes you know frontend JavaScript. "The System Prompt" is a slide lesson with an analogy: a system prompt is "like giving your AI a job description before it starts working for you." The useful part is the demo. The same question, "I want to learn AI engineering," gets a wall of text without a system prompt and a set of clarifying questions with one. She also points to public collections of real system prompts on GitHub, which is a good rabbit hole. The setup scrim is the longest of the group at just over six minutes, and you need it. The app is a vanilla JavaScript chat page bundled with Vite, using the `ai` package (version 5.0.x) and `@openrouter/ai-sdk-provider`. You create an OpenRouter account, make a key, pick one of the free models she lists, and save both as Scrimba environment variables. A `verifyEnv()` helper tells you if you got the names wrong. She is upfront that the free models come with a privacy trade: "in a real world app with sensitive user data, you would use paid models and keep these settings turned off." Then the first mini challenge: add a `system` property to the `streamText` call so the model asks questions instead of assuming. It is one line, and the point is to make you read the SDK docs. The System Prompt Challenge extends that: a dropdown with three personas (Assistant, ELI5, Coach) and an empty `systemPrompts` object you fill in and wire to the selected value. The wrap-up suggests stretch goals, such as letting users add their own rules or saving the persona to localStorage. ### 2. The context window and trimming (15 min, 4 scrims) "Managing The Context Window" is the concept lesson. The comparison is a chat on your phone: you can scroll, but only part of the conversation is on screen at once. The line that lands is about what happens when you exceed the limit: "Your app doesn't get slow. It doesn't give a warning. It just crashes." She also explains why you cannot fix it by buying a bigger model: more context means slower and more expensive responses, and past a point the answers get worse. ![Learn Context Engineering, Context Window Demo slide: a diagram shows older messages greyed out outside the context window box.](https://scrimbaguide.tech/img/scrimba/learn-context-engineering/context-window-demo-sliding-window-slide.webp) *The sliding window diagram at 2:14 of the Context Window Demo. The code version is one line: messages.slice(-10).* Screenshot of scrimba.com, taken by scrimbaguide.tech. A 78-second Scrimba Docs promo by Tom Chant sits next, then the Context Window Demo. The app now starts with a long preloaded conversation and two counters, one for total messages and one for what is being sent. The code switches from `textStream` to `fullStream` so you can catch error events. You send one message, get the context-length error, and the mini challenge is to send only the last ten messages. The solution is `messages.slice(-10)`. The Context Window Challenge gets specific. "AI models don't actually process messages the way humans do. They process tokens," and messages vary wildly in size, so counting messages is the wrong unit. The error message this time is specific: 38,000 tokens requested against a 32,000 limit, 26,000 of them input. Her takeaway is that "the model still needs to keep space for future output," so you trim to around 20,000. Your job is to implement `getTrimmedContext(messages, tokenLimit)`: a `while` loop that shifts off the oldest message and recounts with `calculateTokens` until you are under the limit, always keeping at least one message. ![Learn Context Engineering, Context Window Challenge slide: a stacked diagram shows the token budget filling up and overflowing.](https://scrimbaguide.tech/img/scrimba/learn-context-engineering/context-window-challenge-tokens-diagram-slide.webp) *At 1:45 of the Context Window Challenge: the window as a fixed-size container that every user prompt and every AI reply eats into.* Screenshot of scrimba.com, taken by scrimbaguide.tech. ![Learn Context Engineering, Context Window Challenge: the code editor shows a numbered task list above an unfinished function.](https://scrimbaguide.tech/img/scrimba/learn-context-engineering/context-window-challenge-brief-lesson.webp) *The challenge brief lives in a comment above the function you have to write. Paused at 5:24, just after Arsala starts the solution walkthrough.* Screenshot of scrimba.com, taken by scrimbaguide.tech. ### 3. Summarizing context (24 min, 3 scrims) "Summarizing Context" opens with a whiteboard that fills up during a meeting. Erasing the oldest notes loses information; condensing them keeps it. The trade-off is stated plainly: every summary is an extra API call, so it costs time and money. "Neither is better, they're just tools for different solutions." Trimming for a FAQ bot, summarizing for an assistant that has to remember preferences and decisions. The Summarizing Context Demo is the most interesting scrim in the course because the first attempt fails on camera. The app calls `generateText` with a system prompt that says "you are an expert at summarizing conversations," and the model replies by continuing the debugging conversation instead. The explanation is a real lesson in how these models work: "If your last message is part of an ongoing conversation, the AI will continue conversing. But if your last message is a clear request for a summary, then the AI will summarize." So the mini challenge is to push a final user message that asks for the summary. Her first wording of that message still produces a half-summary, and she tightens it on screen until it works. You will write better prompts for having watched that. The Summarizing Context Super Challenge is 13 minutes and the biggest piece of work in the course. A fact about the user (they studied economics at Queen's University in Canada) is buried at the start of a long conversation, and a 20,000-token limit forces a summary after your first message. You implement two functions in `summary.js`: `splitForSummary`, which walks from the oldest message forward until what remains fits in half the budget, and `generateSummary`, which appends the summary request and calls `generateText`. The summary goes back into the conversation with the `system` role, "kind of like a previously on recap to the conversation," as she puts it. There are nine hint files for this one. The bonus at the end compares summaries with and without a system prompt, and the second version has less preamble and more structure. ### 4. Outro, certificate, and Scrimbassador pitch (4 min, 3 scrims) An 81-second recap of the three techniques, a 56-second scrim on putting the certificate on LinkedIn, and a two-minute pitch from Per Borgen for Scrimba's referral program. None of it is course content, and you can skip all three. ## What a lesson feels like Most scrims are two to six minutes. Arsala talks over slides for the concepts, then switches to the editor with the chat app running in a preview pane on the right. In the newer Scrimba format used here the project is a real Vite app with a `node_modules` folder, a runner tab and a terminal, so the preview is a live page you type into, not a static frame. Challenges follow one pattern. A "What We'll Build" slide, then a walkthrough of what she has added since the last scrim. The brief sits in a comment block in `main.js` or `summary.js` with a link to the relevant SDK docs, and a `hints` folder holds two to nine numbered markdown files. Then the recording pauses and you code. Scrimba marks five of the scrims with its "Challenge with Instant Feedback" icon in the table of contents. Every scrim has a timestamped transcript under the settings menu. One thing to know before you start: because the app calls a live model, you cannot follow along by watching. You need the OpenRouter key and a model ID set in your Scrimba environment, and the `verifyEnv()` check at the top of `main.js` tells you in the console whether you got them right. ## Free or Pro: exactly what is gated This is a Pro course. The first four scrims carry a SAMPLE badge and can be previewed without a subscription: the intro, the system prompt lesson, the setup walkthrough, and the first mini challenge, about 15 minutes in total. That is enough to see the app and the teaching style. Everything from the System Prompt Challenge onward, meaning the context window lessons, both summarization scrims, and the super challenge, needs Pro. So does the certificate. Pro also covers the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) and the Pro-only channels on Scrimba's Discord; the pricing page lists basic Discord access as a free feature, so the server itself is not gated. See [current plans](https://scrimba.com/our-pricing?via=u42d4986) for what Pro costs in your region. ## How long it takes About an hour of video, but budget two to three hours. The OpenRouter setup happens on another site and takes a few minutes the first time. The mini challenges are quick. The two real challenges (token trimming and the two summary functions) are where the time goes, especially if you use the hints sparingly. Do it in one evening or split it across two. ## Who it's for, and who should skip it It fits developers who have built at least one AI feature and hit the wall: a chatbot that forgets the brief, a request that fails once the history grows. It also fits anyone partway through the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) who wants the context piece on its own. Skip it if you have never called a model from code; the problem will not feel real yet, and the setup assumes you know what an API key and an environment variable are. Also skip it if you want a framework-specific answer. The course uses vanilla JavaScript, and if you are using the AI SDK's React hooks or a chat framework that already manages history, you will translate the ideas rather than copy the code. [Start Learn Context Engineering on Scrimba](https://scrimba.com/learn-context-engineering-c0u13jhi10?via=u42d4986) ## Prerequisites Scrimba's own list is accurate: JavaScript with DOM manipulation, async/await, and array methods such as `push`, `map` and `slice`. I would add: you should have made one LLM call before, from any language, so the messages array with `role` and `content` is familiar. You also need an OpenRouter account and a free model ID; the setup scrim walks through both. ## Where it fits This is a standalone deepening, not a milestone. Take [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) first for the basics of calling a model. [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) ends with conversation history, and this course is the direct follow-up on what to do with that history. [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) is where a long, tool-filled context bites hardest, so this is good preparation for it. If you want the concepts in prose first, our [what is context engineering](https://scrimbaguide.tech/blog/what-is-context-engineering/) explainer covers the same ground without the code. ## Strengths and limits What it does well: - It shows the crash before the fix. - The failed summary demo teaches more about prompting than most prompting lessons. - The code is small enough to read in full. - The tools (AI SDK 5, OpenRouter) are what you would use anyway. Where it is limited: - It is an hour of material at a Pro price, and three of the 15 scrims are not lessons. - The free-model setup on OpenRouter is a few steps of friction. - The vanilla JS app means React or Next.js developers do some translating. - It stops at summarization; retrieval, memory stores and tool results are other courses. ## Related courses and comparisons - [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/), the fundamentals to take first - [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/), a related approach to grounding LLM output - [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/), where context management matters most - [Build a Support Agent with Vercel AI SDK](https://scrimbaguide.tech/docs/courses/ai/a-support-agent-with-vercel-ai-sdk/), the same SDK in a full project - [Intro to Model Context Protocol (MCP)](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/), the other short Pro course on the AI shelf - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/), if you want the whole track rather than one course **Q: Is Learn Context Engineering free?** No. It is a Pro course. The first four scrims (about 15 minutes, up to the first mini challenge) are free previews marked SAMPLE; the context window lessons, the summarization lessons and the certificate need a subscription. **Q: What is context engineering?** Deciding what goes into the model's context window on each request. In this course that means three things: a system prompt that sets behavior, trimming old messages by token count so a request fits, and replacing older messages with an AI-written summary so the app keeps important facts. **Q: What do you build?** One small chat app, extended scrim by scrim: first a persona dropdown driven by system prompts, then a version that trims history by tokens, then a version that automatically summarizes older messages once the context passes 20,000 tokens. **Q: What tools and versions does it use?** Vanilla JavaScript bundled with Vite 7, the Vercel AI SDK (the ai package, version 5.0.x), and the OpenRouter provider package. You use free OpenRouter models; Arsala lists recommended model IDs in the lessons because they change. **Q: Do I need to install anything?** No. The app runs inside Scrimba's editor. You do need an OpenRouter account, an API key and a model ID saved as Scrimba environment variables, which the setup scrim walks through. **Q: Does it have challenges?** Yes. Three mini challenges (add a system prompt, slice the last ten messages, push a message that asks for a summary), one persona challenge, a token-trimming function, and a two-function super challenge for summarization. Each comes with a hints folder, and five scrims carry Scrimba's instant-feedback icon. **Q: How long does it take?** About an hour of video and two to three hours of work, mostly on the last two challenges. **Q: Who teaches it?** Arsala Khan, who also builds Scrimba's AI Engineer Path. Tom Chant and Per Borgen each appear in one short housekeeping scrim. **Q: Do I need prior AI experience?** Yes. It assumes you have called a model from code and know JavaScript with async/await. Start with Intro to AI Engineering if not. ### Related Guides - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) - [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) - [Model Context Protocol (MCP)](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/) --- # Intro to Dall-E and GPT Vision Source: https://scrimbaguide.tech/docs/courses/ai/dall-e-and-gpt-vision/ Guil Hernandez's Intro to Dall-E and GPT Vision is a 62 minute Pro course: seven scrims on generating and editing images with DALL-E, two on reading images with GPT-4 Vision, and a small FilmFusion poster app in between. It is a clear hour, but the vision code needs a model swap before it runs today. Reviewed inside the course with a Pro account, September 2026. ## Quick answer It fits you if you already call the OpenAI chat API and want to add image generation or image reading to a project. The catch: the two vision lessons request a model name OpenAI has since retired, so you need a one-line fix before they run. If you have no image use case yet, [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) or [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) will teach you more. **Intro to Dall-E and GPT Vision** Generate, edit and vary images with DALL-E, then ask GPT-4 with Vision questions about a photo, all from a browser scrim with your own OpenAI key. - Duration: 1.0 hrs - Level: Intermediate - 15 lessons - Taught by [Guil Hernandez](https://scrimba.com/@Guilh?via=u42d4986) [View on Scrimba](https://scrimba.com/intro-to-dall-e-and-gpt-vision-c036?via=u42d4986) ## Is it worth your time? If you already call OpenAI from JavaScript and you want to add images to an app, yes. An hour gets you every image endpoint (generate, edit, variations) plus the vision side of chat completions, with a tiny project in the middle. Guil's examples are concrete and a little personal: he fixes an unfinished Orlando building with inpainting, feeds his own photo to the variations endpoint, and asks the vision model what laid the blue egg he found in his yard. The code has aged, and it matters more here than in most Scrimba courses. The image lessons still hold up, but the two vision scrims will not run as recorded (the Vision section below has the details), and nothing in the course flags it. Scope is the other limit. Most AI apps never generate or read images. Without an image use case, [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) or [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) will change what you can build more than this will. ## What you'll learn ### Course curriculum 15 scrims, about 68 minutes of player time, in one flat list. The three groups below are mine, not Scrimba's. - Module 1: Image generation with DALL-E (scrims 1 to 7) (41 min, 7 lessons) - Module 2: FilmFusion challenge and solution (scrims 8 and 9) (9 min, 2 lessons) - Module 3: GPT-4 with Vision, recap and wrap-up (scrims 10 to 15) (18 min, 6 lessons) Scrimba's course page has no modules, just 15 scrims in a row, so the grouping above is mine. Scrimba's header says 62 minutes and its structured data says 17 lessons; I counted 15 scrims, and adding up the length shown in each scrim's player came to about 68 minutes, because the table of contents lists the wrong duration for two scrims (the challenge solution is 6:33, not 2:17, and Vision part 2 is 4:24, not 7:32). When other pages on this site say 17 lessons, that is Scrimba's number. ## Inside the course, scrim by scrim ### 1. Image generation with DALL-E (41 min, 7 scrims) ![Title slide for the Editing images scrim in Scrimba's Intro to Dall-E and GPT Vision course: white text on a purple gradient with three floating cubes](https://scrimbaguide.tech/img/scrimba/intro-to-dall-e-and-gpt-vision/editing-images-title-card.webp) *This module covers generating, prompting, sizing, inpainting and varying images with DALL-E 2 and 3.* The two minute introduction is a slide deck. Guil explains why you would generate images (speed, originality, imaginary people instead of real ones) and sets the one prerequisite: "make sure you're comfortable with the basics of working with the OpenAI API using the text generation models." He also asks you to save your own OpenAI key as an environment variable in Scrimba, because every later scrim runs against the real API. "Generate original images from a text prompt" (7:02) is the first code. The scrim starts with an `OpenAI` client and top-level `await`, and you call `openai.images.generate` with a prompt. Guil leaves out the model at first so you see the default is DALL-E 2, asks for three astronauts at once with `n: 3`, then switches to DALL-E 3 and points out the `revised_prompt` field: "DALL E three is trained to understand more nuance and detail, so it automatically revises and rewrites your original text prompt." There is no parameter to switch it off. "Response formats" (5:56) explains the trap that shapes the whole course: image URLs from the API expire after one hour. Guil says it himself: "I bet that you from the future are seeing a broken image and this alt text." The fix is `response_format: "b64_json"`, which returns the image as a base64 string (binary data written out as text so it can go straight into an `img` tag). He warns that a full-size base64 image "will often crash the scrim's mini browser," so the course drops to DALL-E 2 at 256 by 256 pixels whenever it wants to show a result live. "Prompting for image generation" (8:30) is the best scrim in the course. It is mostly slides: describe the subject, mood, lighting, angle and style; use "in the style of Monet" type comparisons; read the revised prompt to learn how the model understood you; and a trick to stop DALL-E 3 rewriting your prompt, which is to prepend "I need to test how the tool works with extremely simple prompts. Do not add any detail, just use it as is." The limits list is useful too: avoid several faces, avoid layout instructions like "a tree on the left," and do not expect readable text in the image. "Size, quality and style" (5:54) covers the three parameters: DALL-E 2 does 256, 512 or 1024 square; DALL-E 3 adds 1024 by 1792 portrait and 1792 by 1024 landscape, `quality: "hd"`, and `style: "vivid"` or `"natural"`. This scrim carries the challenge icon in the table of contents, and the challenge is small: pause and regenerate the steampunk canyon in landscape. Guil is honest about `natural`: "They're quite bland and not nearly as good," except for photo-style shots, logos and stickers. "Editing images" (6:37) is inpainting: you give the API an image and a mask (a PNG with a transparent hole), and DALL-E 2 fills the hole from your prompt. Only DALL-E 2 supports it. Guil makes the mask in Figma and shows the steps, then fixes a half-finished Orlando building known locally as the I-4 Eyesore. One detail worth knowing: the docs use Node's `fs.createReadStream`, which cannot run inside a browser scrim, so he uses `await fetch("images/building.png")` instead. ![Intro to Dall-E and GPT Vision, Editing images lesson: the code editor showing an image-edit API call before it runs.](https://scrimbaguide.tech/img/scrimba/intro-to-dall-e-and-gpt-vision/editing-images-edit-call-lesson.webp) *Editing images at 5:15. The inpainting request is 15 lines, and response_format stays b64_json at 256 by 256 so the result embeds in the mini browser without crashing it.* Screenshot of scrimba.com, taken by scrimbaguide.tech. "Image variations" (4:26) calls `openai.images.createVariation` on a bike photo, then on Guil's own portrait ("it's like looking into an AI generated mirror") and his dog Joey. Again DALL-E 2 only, square PNG under 4 MB. ### 2. FilmFusion challenge and solution (9 min, 2 scrims) The challenge brief (2:17) hands you a form with a movie title input, an art style dropdown and a Generate Poster button, plus an empty `generatePoster` function. The requirements sit in a comment: build a prompt from the title and style, send it to the images endpoint with DALL-E 3 or 2, and render the poster in the output div. Stretch goals: show "Generating poster for..." text on submit, and show an error message if the request fails. ![Intro to Dall-E and GPT Vision, FilmFusion challenge lesson: the code editor showing the project brief as a comment.](https://scrimbaguide.tech/img/scrimba/intro-to-dall-e-and-gpt-vision/filmfusion-challenge-brief-lesson.webp) *At 1:15 of the challenge brief, the form listener already prevents the default submit, and the dependency panel lists the one package the whole course uses.* Screenshot of scrimba.com, taken by scrimbaguide.tech. The solution (6:33, not the 2:17 the table of contents shows) builds the prompt as a template literal, `An imaginative poster inspired by the movie "${movieTitle.value.trim()}" rendered in the ${artStyles.value} art style`, passes it to `generatePoster(prompt)`, and drops the returned URL into an `img`. Guil tests with Back to the Future in Art Deco and admits the poster text "reads as sort of gibberish," which the prompting scrim warned about. The stretch goals become a status line and a `try`/`catch` around the request. ### 3. GPT-4 with Vision, recap and wrap-up (18 min, 6 scrims) ![Title slide for the GPT-4 with Vision scrim in Scrimba's Intro to Dall-E and GPT Vision course, on a purple gradient.](https://scrimbaguide.tech/img/scrimba/intro-to-dall-e-and-gpt-vision/gpt-4-with-vision-title-card.webp) *This module switches from generating images to reading them, sending a text-and-image content array to chat completions.* Lesson title slides from scrimba.com. "GPT-4 with Vision, Part 1" (7:32) switches endpoints. Vision goes through `openai.chat.completions.create`, and the user message's `content` becomes an array with two objects: `{ type: "text", text: ... }` and `{ type: "image_url", image_url: { url } }`. The image must be a hosted URL, not a local path; Guil uploads his photos to the scrim and links to them. The egg example is the one to watch: the first answer says "thrush family, like the American Robin," so he adds "small egg" and "during spring" to the prompt and gets northern mockingbird, which matches his yard. ![Intro to Dall-E and GPT Vision, GPT-4 with Vision lesson: the code editor, console answer and a photo of an egg.](https://scrimbaguide.tech/img/scrimba/intro-to-dall-e-and-gpt-vision/gpt-4-vision-egg-analysis-lesson.webp) *The content array in view at 4:56 of Vision Part 1 has one object for text and one for image_url, the shape GPT-4 Vision requests use.* Screenshot of scrimba.com, taken by scrimbaguide.tech. The model name is the problem. Guil names it in the transcript as "GPT four vision preview," and that is the model the scrim requests. OpenAI no longer serves that model, so you will need to change the string to a current vision-capable model before any of this scrim's requests return. The request shape itself (text plus image_url in one content array) is still how the API works. "Part 2" (4:24) prices a whole restaurant menu from a photo, notices the total changes on a second run, and compares two cheese photos by adding a second `image_url` object. Guil closes with limits: GPT-4 cannot generate images, uploads are capped at 20 MB, PNG, JPEG, WebP and non-animated GIF are supported, non-Latin text reads poorly, and "OpenAI stressed that the model should not be used for medical advice." The recap (1:48) lists what you did and points you to the Discord "today I did" channel. The last three scrims are Scrimba clips, not course content: Tom Chant on Scrimba Docs (1:18), Per Borgen on the Scrimbassador referral program (1:59), and Per again on using your certificate (0:53). ## What a lesson feels like Every scrim opens on a title slide, then Guil talks over a small `index.js` with a preview popup. Scrims run from under a minute to eight and a half minutes. Because image URLs from the API die after an hour, he often shows results on slides or uploads a saved copy into the scrim, then resets the code at the end so you can run it live with your own key. Expect more slides than live output. There are two challenge moments: the landscape regeneration inside "Size, quality and style," and FilmFusion. Both are the "pause me and try it" kind, not autograded. Every scrim has captions, a timestamped transcript under the settings menu, subtitles in ten languages, and playback speed. ## Free or Pro: exactly what is gated This is a Pro course. The first five scrims carry the SAMPLE badge and play without a subscription: the introduction, generating from a text prompt, response formats, prompting, and size, quality and style. That is 30 minutes and covers the whole generation side. Everything from "Editing images" on is Pro: inpainting, variations, the FilmFusion challenge and solution, both GPT-4 with Vision scrims, the recap, and the certificate. Pro also unlocks the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) this course belongs to and the Pro-only Discord channels. Basic Discord access is free on Scrimba's pricing page, so the server alone is not a reason to upgrade. See [current plans](https://scrimba.com/our-pricing?via=u42d4986) for what Pro includes in your region. There is one cost the course does not gate but you should budget for: your own OpenAI API key. Every example calls the real API, and DALL-E 3 HD images cost more per image than standard ones, which Guil shows on a pricing chart in scrim 5. ## How long it takes 62 minutes is video runtime. Plan for two and a half to four hours: an hour of watching, an hour of running each example with your own key and swapping prompts, and one to two hours on FilmFusion if you do the stretch goals and style it. ## Who it's for, and who should skip it It fits you if you have built something with the OpenAI chat API, want to add image generation or image understanding to it, and would rather see every parameter demonstrated once than read the docs cold. It is also a gentle first look at multimodal models (models that accept more than one kind of input, here text and images). Skip it if you have never called an AI model from code; do [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) first, since this course assumes the chat completions basics. Skip it if you need the current OpenAI image model, because only DALL-E 2 and 3 appear here. And skip it if you want image work outside OpenAI; no other provider is mentioned. [Preview the first five scrims free on Scrimba](https://scrimba.com/intro-to-dall-e-and-gpt-vision-c036?via=u42d4986) ## Prerequisites JavaScript with `async`/`await` and template literals, a working knowledge of the OpenAI chat completions API, and an OpenAI API key saved as an environment variable in Scrimba. Figma is used for one mask in the editing scrim, but any tool that exports a PNG with transparency will do. ## Where it fits Scrimba lists this course under the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/). Treat it as an elective: take it when a project needs images, not as a step everyone must pass. The natural neighbours are [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) before it and [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) or [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) after it. ## Strengths and limits What it does well: it covers every images endpoint and the vision request shape in an hour, the prompting scrim is the most reusable eight minutes in it, the FilmFusion challenge is small enough to finish, and Guil explains the one-hour URL expiry and the base64 crash before you hit them. Where it is limited: the code has not been updated since it was recorded, editing and variations are DALL-E 2 only, there is no coverage of OpenAI's newer image model, and half the visuals are pre-generated slides because live output cannot survive the scrim's preview. ## Related courses and comparisons - [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/), the fundamentals to take first - [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/), for grounding text-based AI apps - [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/), for AI that acts rather than describes - [Intro to Mistral AI](https://scrimbaguide.tech/docs/courses/ai/mistral-ai/), a free way to practise LLM app patterns - [Prompt Engineering for Web Developers](https://scrimbaguide.tech/docs/courses/ai/prompt-engineering-for-web-developers/), if the prompting scrim was your favourite part **Q: Is Intro to Dall-E and GPT Vision free on Scrimba?** No, it is a Pro course, but the first five scrims (about 30 minutes, the whole image generation side) are free previews marked SAMPLE. Editing, variations, the FilmFusion challenge, both GPT-4 with Vision scrims and the certificate need Pro. **Q: How long is it and how many lessons does it have?** Scrimba says 62 minutes and 17 lessons. I counted 15 scrims, and their player lengths add up to about 68 minutes. Plan two and a half to four hours to run the examples with your own key and build FilmFusion. **Q: Who teaches it?** Guil Hernandez, a Scrimba teacher who also made Learn to Code with AI and Learn RAG. Three short clips at the end are from Tom Chant and Per Borgen and are about Scrimba features, not DALL-E. **Q: What do you build?** FilmFusion, a one-page app where you type a movie title, pick an art style from a dropdown, and get a DALL-E poster. Stretch goals add a status message and error handling. Everything else is a series of short examples: generating, editing, varying and analysing images. **Q: Do I need an OpenAI API key?** Yes. Every scrim calls the real API. Guil asks you in the introduction to save your key as an environment variable in Scrimba. DALL-E 3 HD images cost more per image than standard, so budget for a few dollars of experiments. **Q: Does the code still work in 2026?** The DALL-E 2 and 3 examples run as written. The two vision scrims call gpt-4-vision-preview, which OpenAI has retired, so change the model string to a current vision-capable model first. The request shape (text plus image_url in one content array) is unchanged. The SDK pinned in the scrims is openai@4.20.0. **Q: Are there challenges?** Two, both of the pause-and-try kind: regenerate an image in landscape inside the size, quality and style scrim, and the FilmFusion project with a full solution walkthrough. Nothing is autograded. **Q: Does the course have transcripts or subtitles?** Yes. Every scrim has captions, a timestamped transcript panel under the settings menu, and subtitles in ten languages. ### Related Guides - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) - [Scrimba AI Courses](https://scrimbaguide.tech/docs/courses/ai/) - [Build a Support Agent with Vercel AI SDK](https://scrimbaguide.tech/docs/courses/ai/a-support-agent-with-vercel-ai-sdk/) --- # Intro to Mistral AI Source: https://scrimbaguide.tech/docs/courses/ai/mistral-ai/ Intro to Mistral AI is Scrimba's free, 84-minute course on building with Mistral's models in JavaScript, taught mainly by Per Borgen with Gil Hernandez and Mistral's Sophia Yang. In 25 scrims you build a RAG bot over an employee handbook and a function-calling agent, and it earns its short runtime. Reviewed inside the course with a Pro account, September 2026. ## Quick answer It fits developers who already know JavaScript and want a free, hands-on build of a RAG bot and a function-calling agent. The catch is setup, not price: Mistral requires a card on file before it issues an API key, and the RAG section needs a free Supabase project too. From here, [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) covers retrieval in more depth, and [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) takes the agent loop further. **Intro to Mistral AI** Chat completions, a handbook RAG bot on Supabase, a function-calling agent loop, and local inference with Ollama, all in JavaScript and all free. - Duration: 1.4 hrs - Level: Intermediate - 25 lessons - Taught by [Per Borgen](https://scrimba.com/@perborgen?via=u42d4986) [Start free on Scrimba](https://scrimba.com/intro-to-mistral-ai-c035?via=u42d4986) ## Is it worth your time? Yes, if you can write JavaScript and want to see RAG and function calling built end to end without paying for a course. For 84 minutes it covers a lot of ground, and it does so with the two projects that matter most on the AI track. One is a question-answering bot grounded in your own documents. The other is an agent that turns a sentence into a function call. Both are the same patterns you meet later in the paid AI courses, here in their simplest form. Per sets the tone in the first minute: "My goal with this course is to teach you how to build magical stuff and more specifically, how to do that using JavaScript and Mistral AI." He keeps it that direct throughout. The challenges are short and the solutions follow right after, so nobody gets stuck for long. Two caveats. First, it is a 2024 recording. Per warns in the models scrim that "these are the models it offers at the time of recording," and the model names (`mistral-tiny`, `mistral-medium-latest`) and the 0.1 client library show their age. Second, you cannot follow along with a free Scrimba account alone. Mistral asks for a card before it issues an API key, and Supabase needs its own project and two SQL snippets pasted into its editor. ## What you'll learn The course is one flat list of scrims, so the grouping below is mine, in order. ### Course structure 25 scrims in 5 editorial groups, plus 3 generic Scrimba pages - Module 1: Welcome, Mistral intro, and La Plateforme signup (6 min, 3 lessons) - Module 2: Chat completions, streaming, JSON, and choosing a model (13 min, 3 lessons) - Module 3: RAG: embeddings, chunking, Supabase, retrieval, generation (41 min, 11 lessons) - Module 4: Function calling: from a tool schema to an agent loop (17 min, 6 lessons) - Module 5: Running Mistral locally with Ollama, and the recap (5 min, 2 lessons) Group durations are added up from the timer in each scrim's header and come to 82 minutes; Scrimba's header rounds the course to 84. Scrimba's About text says 25 lessons. The table of contents has 28 entries because it ends with three pointer pages (Scrimba Docs, the affiliate program, and how to use your certificate); my counts above are the 25 real lessons. ## Inside the course, module by module ### 1. Welcome, Mistral intro, and La Plateforme signup (6 min, 3 scrims) ![Title card of Scrimba's Intro to Mistral AI course: Scrimba Course, Intro to Mistral AI, course teacher Per Borgen](https://scrimbaguide.tech/img/scrimba/intro-to-mistral-ai/chapter-1-intro-to-mistral-ai-title-card.webp) *Per lays out the plan, then the La Plateforme signup and its pay-per-use pricing, no fixed subscription.* Per's welcome explains what Mistral is (a company that "twice managed to stun the AI community by launching small open source foundational models") and lays out the plan. In order: API basics, models, embeddings and vector databases, RAG, function calling, then local models. He also says the course "has been created in partnership with the company itself." Sophia Yang's two minutes are a company brief: founded in 2023, Mistral 7B and Mixtral 8x7B as open weights under Apache 2.0, and Small, Medium, and Large as the paid tier. The third scrim is the signup walkthrough. It is the one to watch before deciding whether to take the course, because it tells you the cost model plainly: "you only pay for what you use. So this is not an ongoing fixed subscription." You add a card, create a key, and store it as a Scrimba environment variable. ### 2. Chat completions, streaming, JSON, and choosing a model (13 min, 3 scrims) Gil Hernandez teaches the first request. The code is small: import `MistralClient`, call `client.chat` with a `model` and a `messages` array, and read `chatResponse.choices[0].message.content`. He then adds `temperature` and a `system` message, and pauses twice for you to change the prompt yourself. Gil also uses this scrim to point out where you are. "You are experiencing a fully interactive scrim that you can pause at any moment and jump right into the code and make changes to it." Per takes over for part two, which adds two settings you will use in every app. Streaming means switching `chat` to `chatStream` and reading chunks with a `for await` loop, and Per shows why by typing a question into a Hugging Face chat page and watching the reply build "token by token." JSON output takes two changes: set `response_format` to `json_object` and ask for JSON in the prompt. The models scrim compares Mistral's open and paid models on the MMLU benchmark (a standard test for language models) and then on cost. The advice is to pick the cheapest model that does the job. As Per puts it, "you probably don't want to hire a person that is overeducated or overqualified for the job because most likely their hourly rate will be higher." The course uses `mistral-large-latest` for RAG and the agent because those need reasoning. ### 3. RAG: embeddings, chunking, Supabase, retrieval, generation (41 min, 11 scrims) This is half the course, and it is built as one project: a bot that answers questions about a fictional company's employee handbook (`handbook.txt`, about 600 lines). Per explains RAG (retrieval-augmented generation, meaning you look up relevant text first and hand it to the model as context) with a story about asking Notion's AI where Scrimba keeps its Coursera export notes. Gil then gives a six-minute primer on embeddings, the numeric form of text that lets you compare meaning. "You can think of embeddings as the language that AI understands," he says, and walks through the classic king minus man plus woman example. The build starts with chunking. Per imports `RecursiveCharacterTextSplitter` from LangChain, sets a chunk size of 250 characters with an overlap of 40, and inspects the 280 chunks that come out. His rule: "you want your chunks to be as small as possible, but you don't want to lose context." A short challenge has you refactor `splitDocument` to take a path and return an array of strings. Then you create one embedding with `client.embeddings` and the `mistral-embed` model, and the first real challenge asks you to embed every chunk and shape the result for the database. ![Intro to Mistral AI, embeddings challenge screen: a code editor shows only a comment brief, no code written yet.](https://scrimbaguide.tech/img/scrimba/intro-to-mistral-ai/embeddings-challenge-brief-lesson.webp) *At 0:49 of the embeddings challenge brief, Per has deleted his own code from the previous scrim: 'yeah, this is Scrimba. You are going to write the code on your own.'* Screenshot of scrimba.com, taken by scrimbaguide.tech. Gil returns for two Supabase scrims: what a vector database is, and a click-by-click setup of a free Supabase project with the pgvector extension, ending with two more environment variables. One quirk: the editor in those two scrims still shows OpenAI code from another course (`text-embedding-ada-002`), which is unrelated to the walkthrough. Per then creates the `handbook_docs` table with a SQL snippet (the embedding column is a 1024-dimension vector, matching `mistral-embed`) and uploads everything with a single `supabase.from('handbook_docs').insert(data)`. Retrieval uses a similarity function that Supabase supplies. Per is upfront that the math behind it stays in the box: "Luckily, we don't have to worry about any of that as Supabase provides us with a SQL function that we simply can copy paste." You call it with `supabase.rpc`. The first result for "December 25th is on a Sunday, do I get an extra day off?" comes back as a cut-off sentence about Christmas Day. The final two-part challenge fixes that: return five matches instead of one, then write the prompt that combines context and question and send it to `mistral-large-latest`. ![Intro to Mistral AI, RAG lesson: a code editor beside a console printing a full sentence answer from the handbook bot.](https://scrimbaguide.tech/img/scrimba/intro-to-mistral-ai/rag-handbook-answer-in-console-lesson.webp) *The finished RAG bot's prompt at 3:57 of the last RAG scrim is just 'Handbook context:' plus the five chunks and 'Question:' plus the query.* Screenshot of scrimba.com, taken by scrimbaguide.tech. ### 4. Function calling: from a tool schema to an agent loop (17 min, 6 scrims) ![Title card for the function calling section of Scrimba's Intro to Mistral AI course, with three floating cubes](https://scrimbaguide.tech/img/scrimba/intro-to-mistral-ai/chapter-4-function-calling-title-card.webp) *Six scrims build a customer-service agent, from a tool schema to reading tool_calls and looping to an answer.* The agent is a customer-service bot over a tiny array of transactions in `tools.js`. Per's opening point is the one people miss: the model never runs your code. "This is all our AI sees. It never sees the content of this function. It just looks at the description and tries to decide whether or not it should be invoked." The first scrim sends the prompt "Is the transaction T1001 paid?" with a `tools` array, and the reply has an empty `content` and a `tool_calls` entry naming `getPaymentStatus`. ![Intro to Mistral AI, function calling lesson: a code editor shows the model's raw response object after a tool call.](https://scrimbaguide.tech/img/scrimba/intro-to-mistral-ai/function-calling-tool-calls-response-lesson.webp) *Per pastes the reply into output.js at 3:11. The two fields the section builds on are tool_calls and finish_reason: 'tool_calls' means the model wants you to run something and report back.* Screenshot of scrimba.com, taken by scrimbaguide.tech. The next five scrims each add one piece, and each is a challenge: - Describe a second function, `getPaymentDate`, in the tool schema and change the prompt to trigger it. - Read the function name out of the response and `JSON.parse` its arguments. - Call it through an `availableFunctions` object with bracket notation. - Push a message with `role: 'tool'` back into the messages array. - Wrap it all in a `for` loop that runs at most five times and returns when `finish_reason` is `stop`. Per explains the cap: a `while` loop or recursion "could be better solutions, but they also open up for the possibility of infinite loops." The last run prints "The transaction T1001 was paid on October 5, 2021." ### 5. Running Mistral locally with Ollama, and the recap (5 min, 2 scrims) ![Title card for the Running Mistral locally scrim in Scrimba's Intro to Mistral AI course](https://scrimbaguide.tech/img/scrimba/intro-to-mistral-ai/chapter-5-running-mistral-locally-title-card.webp) *The one scrim outside the browser: ollama run mistral, then a small Express server that talks to it locally.* Screenshot of scrimba.com, taken by scrimbaguide.tech. The Ollama scrim is the only one that leaves the browser. You install Ollama, run `ollama run mistral` (a 4.1 GB download), chat with it in the terminal, then download the scrim as a zip, `npm install`, and start a 24-line Express server that passes a URL query to `ollama.chat`. Per's sell is simple: "aside for the cost of the hardware and the electricity, these tokens are completely free," and the data stays on your machine. The recap is 77 seconds. After it come the three generic Scrimba pages, which have no video. ## What a lesson feels like Scrims run one to six minutes; the longest is Gil's embeddings explainer. Per and Gil talk over a slide for the concept, then switch to the editor and run the code, and you see the API response arrive in the console. Challenges are written into the file as a comment block, the narration says "go ahead and solve this," and the recording sits quiet for a few seconds before the solution starts. You are meant to pause there, write your version, and press play. Every scrim has captions, a timestamped transcript under the settings menu, subtitles in ten languages, and playback speed. The API calls are real, so running Per's code yourself spends a fraction of a cent on your Mistral account each time. Nothing in the course marks your work automatically; the check is whether your console shows what Per's shows. ## Free or Pro: exactly what is gated Nothing inside the course. All 25 teaching scrims play in full without Pro, there is no Solo Project, and the challenges are plain comment blocks in the editor rather than Scrimba's AI-checked challenge format. The only item I did not test is the Certificate of Completion entry at the very end of the list; Scrimba's pricing page lists certificates as a Pro feature. Pro is a separate decision. It buys the full [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) (this free course is not part of it), the Pro-only Discord channels (basic Discord access is free), unlimited challenges, and certificates. See [current plans](https://scrimba.com/our-pricing?via=u42d4986) for what it costs in your region. ## How long it takes Budget three to five hours, not 84 minutes. The account setup alone (Mistral card and key, Supabase project, pgvector extension, three environment variables, two SQL snippets) is 30 to 60 minutes the first time. The RAG and function-calling challenges are short, but each one is worth writing yourself before watching the solution. The Ollama scrim adds a 4 GB download and a local `npm install`, so do it when you have time and disk space. ## Who it's for, and who should skip it It fits developers with working JavaScript who want to build a RAG bot and a tool-calling agent once, from scratch, before touching a framework. It is also a good way to try Mistral if you have only used OpenAI: the client, the messages array, and the tool schema all rhyme with what you know. Skip it, for now, if you have never written `async`/`await` or called an API; start with [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) or [Learn to Code with AI](https://scrimbaguide.tech/docs/courses/ai/to-code-with-ai/). Also skip it if you will not put a card on file with Mistral, because the course cannot be followed past scrim three without a key. And if you want current SDK syntax rather than the concepts, read Mistral's docs alongside it. [Start Intro to Mistral AI for free](https://scrimba.com/intro-to-mistral-ai-c035?via=u42d4986) ## Prerequisites JavaScript with `async`/`await`, arrays and `map`, and a basic sense of what an API request is. No AI experience is assumed; embeddings and RAG are explained from zero. You will need a Mistral La Plateforme account with a card, a free Supabase account (GitHub login works), and, for the last scrim, a computer that can run Ollama and hold a 4 GB model. ## Where it fits This course sits outside the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/), but it works as a compact, free preview of two paid courses on it. [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) covers the retrieval pipeline in more depth, and [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) takes the function-calling loop further. [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) is the fundamentals course that most people take first; this one works either as a taster before it or a second provider after it. ## Strengths and limits What it does well: it is free, and it builds a real RAG pipeline and a real agent loop rather than talking about them. The challenges sit exactly where you would otherwise copy code. Per explains the trade-offs as he goes, from chunk size to model cost to the five-iteration cap. Where it is limited: it was recorded in early 2024 and pins Mistral's 0.1 client, so the model names and SDK calls will not match current docs. It needs two external accounts and a card before the main project runs. The Supabase scrims show leftover OpenAI code in the editor, and because the user input is hard-coded you never wire the bot to a page. ## Related courses and comparisons - [Learn to Code with AI](https://scrimbaguide.tech/docs/courses/ai/to-code-with-ai/), the free beginner on-ramp - [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/), the deeper paid fundamentals - [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/), the same retrieval pipeline in more depth - [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/), where the function-calling loop goes next - [Learn Supabase](https://scrimbaguide.tech/docs/courses/backend/supabase/), for the database side used here - [Build Serverless AI Agents with Langbase](https://scrimbaguide.tech/docs/courses/ai/serverless-ai-agents-with-langbase/), another free AI course **Q: Is Intro to Mistral AI free on Scrimba?** Yes. All 25 teaching scrims play without a subscription and there is no Pro-only project inside it. You do need your own Mistral API key, which requires a card on file at La Plateforme, and a free Supabase project for the RAG section. **Q: Who teaches it?** Per Borgen, Scrimba's co-founder, teaches the welcome, the models, the RAG build, function calling, and Ollama. Gil Hernandez teaches the first chat completion, embeddings, and the Supabase setup. Sophia Yang from Mistral records the two-minute company intro. **Q: What do you build?** A question-answering bot over a fictional employee handbook (chunked with LangChain, embedded with mistral-embed, stored and searched in Supabase), and a small customer-service agent that decides when to call getPaymentStatus or getPaymentDate and loops until it has an answer. The last scrim runs Mistral locally behind a tiny Express server. **Q: Is it good for complete beginners?** No. It assumes async/await, array methods, and comfort with API calls, and it does not reteach them. Start with Learn JavaScript or Learn to Code with AI first. **Q: Is the content up to date?** The concepts are, the code is not fully. It was recorded in early 2024 with version 0.1 of Mistral's JavaScript client and model names like mistral-tiny and mistral-medium-latest. Expect to translate the calls when you read Mistral's current docs. **Q: How long does it take?** About 84 minutes of video. Plan for three to five hours with account setup and the challenges, plus a 4 GB download if you do the Ollama scrim. **Q: Are there transcripts and captions?** Yes. Every scrim has captions, a timestamped transcript under the settings menu, subtitles in ten languages, and adjustable speed. **Q: Are the challenges AI-checked?** No. Challenges are comment blocks in the editor and the recording pauses for you; you compare your console output with Per's. The AI-checked challenge format used in some Scrimba courses is not used here. ### Related Guides - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) - [Scrimba AI Courses](https://scrimbaguide.tech/docs/courses/ai/) - [Build a Support Agent with Vercel AI SDK](https://scrimbaguide.tech/docs/courses/ai/a-support-agent-with-vercel-ai-sdk/) --- # Intro to Model Context Protocol (MCP) Source: https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/ Maham Codes teaches Intro to Model Context Protocol (MCP) in about 37 minutes across 17 scrims. You build a small weather MCP server in Node.js and TypeScript, with one tool, one resource, and a STDIO transport. It's Pro, and it's the fastest way to get a working MCP server rather than just watch one explained. Reviewed inside the course with a Pro account, September 2026: all 17 scrims and transcripts. ## Quick answer This fits developers who already build with an LLM API in JavaScript or TypeScript and want a working MCP server by the end of an afternoon. The catch: the MCP Inspector and Claude Desktop parts are shown on slides, not built in the browser, and the third MCP building block, prompts, is explained but never coded. If you have never called an AI model from code, start with [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) instead; this course will feel abstract without that foundation. **Intro to Model Context Protocol (MCP)** A short build-along on MCP: what it is, then a weather MCP server in TypeScript with a tool, a resource, and a STDIO transport. - Duration: 37 min - Level: Intermediate - 17 lessons - Taught by [Maham Codes](https://scrimba.com/@MahamDev?via=u42d4986) [View on Scrimba](https://scrimba.com/intro-to-model-context-protocol-mcp-c0sake4uir?via=u42d4986) ## Is it worth your time? Yes, if MCP is a gap you need to close quickly. The whole thing is shorter than a lunch break. By scrim 7 you have a server that starts, prints the tool and resource it registered, and says "Server ready!" in Scrimba's built-in terminal, a small working build rather than a slide deck. The server is tiny on purpose: two hardcoded cities, no real API. The MCP Inspector and Claude Desktop parts are shown on slides and screen recordings, so you watch them rather than do them in the browser. And the third MCP building block, prompts, is explained but never coded. Maham says it outright in lesson 7: "prompts are optional." If you want a deeper tool-using build, [Build a Support Agent with Vercel AI SDK](https://scrimbaguide.tech/docs/courses/ai/a-support-agent-with-vercel-ai-sdk/) goes much further. One thing that surprised me: four of the 17 scrims are not Maham's. They are short AI-generated explainers with a quiz at the end, added by Scrimba in September 2026. More on those below. ## What you'll learn Scrimba lists this course as a flat list of 17 scrims with no modules. The four groups below are mine, so you can see how the time is spent. ### Course curriculum 4 modules · 17 lessons - Module 1: What MCP is and how it is built (13 min, 4 lessons) - Module 2: Build the weather MCP server (17 min, 3 lessons) - Module 3: Transports, security, and clients (10 min, 6 lessons) - Module 4: Wrap up and Scrimba extras (7 min, 4 lessons) I counted 17 scrims, about 47 minutes in total, which now matches Scrimba's own listing of 17 lessons. The header's 37 minute runtime predates the four AI explainers and the housekeeping scrims (feedback form, Scrimba Docs, the Scrimbassador pitch, and the certificate note) added later, so the duration no longer matches what you see inside. ## Inside the course, module by module ### 1. What MCP is and how it is built (13 min, 4 scrims) The Introduction is a two and a half minute video with slides. Maham's framing: models like GPT, Claude, or Gemini feel "magical" when they use tools, but "it's not just the model itself doing the magic. It's context." She calls the course a "module" throughout; it reads like it was cut from a longer curriculum. "Intro to MCP and its importance" names the two problems MCP solves. Models do not know recent things, and stuffing context into a prompt is expensive because you pay per token. Then comes the analogy the course leans on: "Think of MCP like a USB C for AI." One connector, any device. She ends on the architecture. An MCP client lives inside a host app such as an IDE, and you can plug several MCP servers into it, each wrapping a different data source. "Core MCP concepts and architecture" is the lesson to rewatch. It defines the three building blocks. Resources are like HTTP GET requests: they return data and change nothing. Tools are like HTTP POST requests: they do something, such as sending an email or booking a hotel room. Prompts are reusable templates. As Maham puts it in lesson 3, "use a resource when your agent needs to read or retrieve information and use a tool when your agent needs to do something." Transports get a one line preview: STDIO for local work, streamable HTTP for production. The fourth scrim, "MCP: Resources vs Tools," is the first of the AI explainers. It is a 100 second narrated slide deck ("Resources are like a library where the AI reads information, while Tools are like a workshop") that ends with a quiz question. A note on the page says the content was generated by AI and hand-checked by Tom from Scrimba. ### 2. Build the weather MCP server (17 min, 3 scrims) ![Title slide of the Setting up an MCP server lesson in Scrimba's Intro to Model Context Protocol course, teacher Maham Codes.](https://scrimbaguide.tech/img/scrimba/intro-to-model-context-protocol-mcp/chapter-building-mcp-server-title-card.webp) *Three scrims build a weather MCP server: an example tool first, then a challenge to write getWeatherDataByCityName yourself.* ![Title slide of the Running the MCP server lesson in Scrimba's Intro to Model Context Protocol course, teacher Maham Codes.](https://scrimbaguide.tech/img/scrimba/intro-to-model-context-protocol-mcp/chapter-prompts-and-running-the-server-title-card.webp) *After a two-line note that prompts are optional, this scrim wires up the STDIO transport and gets the server running in Scrimba's terminal.* Lesson title slides from scrimba.com. This is the part you will remember. "Setting up an MCP server and defining tools" is the longest scrim at 7:23 and the first with real code. You run `npm init -y` and install `@modelcontextprotocol/sdk` and Zod (a small library for validating inputs). Then you create `server.ts` with a `new McpServer({ name: 'Weather Data Fetcher', version: '1.0.0' })`. Maham then registers an example tool, `trackPackage`, so you can see the shape. A tool has a name, a description, a Zod schema for the input, and an async function that returns `{ content: [{ type: 'text', text: ... }] }`. Then the recording stops and it is your turn. The brief is written as a comment in the file: create a tool called `getWeatherDataByCityName` that takes a city and returns mock weather as JSON text, using the `getWeatherByCity` helper she just wrote. "I'll wait here so that you can try it yourself," she says at 6:01. "Don't worry if you're not able to do it. We'll do it together once you're back." ![Intro to MCP, Setting up an MCP server lesson: code editor showing an example tool above a coding challenge.](https://scrimbaguide.tech/img/scrimba/intro-to-model-context-protocol-mcp/weather-tool-challenge-brief-lesson.webp) *The challenge at 6:08. Above the brief is the example tool and the helper you are meant to reuse; below it is the empty space where you write your own server.tool() call before she shows hers.* Screenshot of scrimba.com, taken by scrimbaguide.tech. "Registering resources in the MCP server" follows the same pattern. Maham shows a resource with an example URI (`flights/airports`), a description, a MIME type, and a function that returns the content. Your challenge: a `weather://cities` resource that returns a plain text list of London and New York. Both of these scrims warn you that nothing runs yet, because there is no transport. "Running the MCP server" fixes that. After a short detour on prompts (optional, and skipped in code), you import `StdioServerTransport`. You then write an `init()` function that creates the transport, calls `await server.connect(transport)`, and logs a few status lines. The challenge here is to write that `init()` yourself. There is a good, practical explanation of why the logs use `console.error` rather than `console.log`. With STDIO, standard output is the channel the protocol messages travel on, so writing to it "might accidentally interfere with the protocol messages." Then you add `"type": "module"` to package.json, run `npm install`, and `npx tsx server.ts` in Scrimba's terminal. ![Intro to MCP, Running the MCP server lesson: terminal output showing the server starting successfully.](https://scrimbaguide.tech/img/scrimba/intro-to-model-context-protocol-mcp/running-the-server-terminal-lesson.webp) *The payoff at 5:27: the server starts inside Scrimba's terminal and prints the tool and resource it registered. The terminal also shows tsx 4.20.3 being installed on the fly.* Screenshot of scrimba.com, taken by scrimbaguide.tech. The versions: `@modelcontextprotocol/sdk` 1.15, Zod 3.25, TypeScript 5.8. The MCP SDK moves fast, so check the current docs if you build this outside Scrimba. ### 3. Transports, security, and clients (10 min, 6 scrims) "Transports" is a two and a half minute slide lesson. A transport is how client and server exchange messages. STDIO uses the process's input and output streams and suits local tools. Streamable HTTP sends each message as an HTTP POST and can stream replies back. As Maham puts it, use it "when you want any kind of web based integrations that's not on the same machine." You do not implement the HTTP transport. Three more AI explainers sit around this lesson: - "MCP Capability Discovery" covers how a client finds out which tools a server offers. - "MCP Trust Boundaries" explains that the host app decides which tools the model may use, and that risky actions should need user approval. - "Local vs Remote MCP Servers" contrasts the two setups. Each is 75 to 90 seconds, ends with a quiz question, and carries the line "Explain is AI and can make mistakes." They reference a newer MCP spec than Maham's lessons, so treat them as pointers, not settled facts. A 12 second "Share Your Feedback" scrim asks what you think of them. "MCP clients" is Maham's last teaching scrim and the one that ties the pieces together. An MCP client, in her words, is "the smart connector inside a host app that talks to your MCP server." She opens MCP Inspector with `npx @modelcontextprotocol/inspector@latest`, points it at the weather server, and calls the tool for London by hand. Then she opens Claude Desktop, edits the developer config, and asks "what's the weather in London?" so Claude calls the tool. Both demos are screen recordings. You cannot repeat them inside the scrim, but the config is short enough to copy. ![Intro to MCP, MCP clients lesson: a slide showing a Claude Desktop configuration file.](https://scrimbaguide.tech/img/scrimba/intro-to-model-context-protocol-mcp/claude-desktop-config-lesson.webp) *The Claude Desktop config at 2:59: one mcpServers entry that runs npx tsx server.ts. This is the whole integration; the same server also works with Cursor, VS Code, and other hosts, she notes.* Screenshot of scrimba.com, taken by scrimbaguide.tech. ### 4. Wrap up and Scrimba extras (7 min, 4 scrims) Maham's "Wrap Up" restates the course in two and a half minutes and lists what you can now do: explain MCP, build a server with tools and resources, connect it to a client, and debug it with Inspector. The remaining three scrims are not about MCP. Tom Chant introduces Scrimba Docs, Per Borgen pitches the Scrimbassador referral program, and a 53 second note tells you how to use the certificate on LinkedIn. ## What a lesson feels like There are two kinds of scrim here. The concept lessons (intro, importance, core concepts, transports, clients, wrap up) are narrated slide decks with the occasional screen recording, and there is no code to touch. The three build lessons open a real editor and terminal. Maham types in `server.ts`, and when the challenge comes, the recording pauses with the brief as a comment in the file. You write in the same editor, then press play to watch her version. Those three scrims carry Scrimba's "Challenge with Instant Feedback" icon, which means an AI check of your solution is available. Every scrim has captions and a timestamped transcript in the settings menu, with subtitles in ten languages. Maham's delivery is brisk and scripted, closer to a documentation walkthrough than Per Borgen's chatty style, and precise about details such as the `console.error` point above. If you learn by reading, the transcript panel lets you skim a lesson in a minute. ## Free or Pro: exactly what is gated The course is Pro. Four scrims are marked SAMPLE and open without a subscription: the first three concept lessons plus the first build lesson, "Setting up an MCP server and defining tools." That is the whole conceptual part plus the first challenge, so you can try it for free and decide from there. Everything after that is Pro: registering the resource, running the server, transports, the explainers, the clients lesson, the wrap up, and the certificate of completion. Pro also unlocks the rest of the AI catalog. It adds the Pro-only channels on Scrimba's Discord too (the pricing page lists basic Discord access as free). See [current plans](https://scrimba.com/our-pricing?via=u42d4986) for what Pro costs where you live. ## How long it takes Scrimba says 37 minutes; the 17 scrims add up to about 47. Budget one and a half to two hours to do it properly. The three challenges will take most people ten to fifteen minutes each if they type rather than watch, and the explainer quizzes add a few minutes. Add another hour if you want to run the server on your own machine and connect it to Claude Desktop or Cursor. The course shows that part but does not let you do it in the browser. It is a one-sitting course. ## Who it's for, and who should skip it It fits JavaScript or TypeScript developers who already build with an LLM API and want to expose their own tools to Claude, Cursor, or another MCP host. It also works as a quick briefing for people on the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) who want to know what MCP is before they meet it in a bigger project. Skip it if you have never called a model from code; the problem MCP solves will not feel real yet. Skip it, too, if you want production depth: authentication, remote servers, and the streamable HTTP transport are named but not built. [Start Intro to Model Context Protocol (MCP) on Scrimba](https://scrimba.com/intro-to-model-context-protocol-mcp-c0sake4uir?via=u42d4986) ## Prerequisites Comfortable JavaScript and enough TypeScript to read a typed function signature. The course uses `async`/`await`, ES modules, and npm without explaining them, and no MCP experience is assumed. If TypeScript is the gap, [Learn TypeScript](https://scrimbaguide.tech/docs/courses/typescript/learn-typescript/) covers it; [Learn Node.js](https://scrimbaguide.tech/docs/courses/javascript/nodejs/) helps with the npm and terminal side. ## Where it fits This is a standalone course, not a step in a path. It pairs with [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/), which teaches how a model decides to call a tool. This course teaches how to package tools so any host can call them. [Learn Context Engineering](https://scrimbaguide.tech/docs/courses/ai/context-engineering/) covers the other half of "context," what you put in the prompt. ## Strengths and limits What it does well: - Explains resources versus tools with a comparison (GET versus POST) that sticks. - Gets you to a running server in three short lessons, with a challenge in each. - Covers small practical things, such as why to log with `console.error`. - The Inspector and Claude Desktop demos show the finished loop end to end. Where it is limited: - The server is a toy with two hardcoded cities. - Prompts and the HTTP transport are described but never coded. - The client demos are watch-only. - The four AI explainers are a different voice and reference a newer spec than the main lessons. - The MCP SDK version pinned in the course will drift. ## Related courses and comparisons - [All AI courses on Scrimba](https://scrimbaguide.tech/docs/courses/ai/), the category hub - [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/), where tool calling is taught from the model's side - [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/), the fundamentals to take first - [Build a Support Agent with Vercel AI SDK](https://scrimbaguide.tech/docs/courses/ai/a-support-agent-with-vercel-ai-sdk/), a fuller tool-using build - [Learn Context Engineering](https://scrimbaguide.tech/docs/courses/ai/context-engineering/), the prompt side of context - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/), if you want the whole track **Q: Is the Scrimba MCP course free?** No, it is a Pro course. Four scrims are free samples: the Introduction, Intro to MCP and its importance, Core MCP concepts and architecture, and Setting up an MCP server and defining tools. The rest, including the certificate, needs Pro. **Q: What do you build in the course?** A weather MCP server in Node.js and TypeScript with one tool (getWeatherDataByCityName, returning mock data for New York and London), one resource (weather://cities), and a STDIO transport. You run it in Scrimba's terminal. Testing it in MCP Inspector and Claude Desktop is shown on slides. **Q: Who teaches Intro to Model Context Protocol?** Maham Codes, a developer relations engineer who also made Build Serverless AI Agents with Langbase on Scrimba. Four short AI-generated explainer scrims were added by Scrimba's Tom Chant in September 2026, and Per Borgen appears in two housekeeping scrims. **Q: How many lessons are there?** I counted 17 scrims, about 47 minutes in total, which now matches Scrimba's own listing of 17 lessons. The header's 37 minute runtime predates the four AI explainers and the housekeeping scrims added later, so the duration no longer matches what you see inside. **Q: Are there challenges?** Yes, three. Write the weather tool, write the cities resource, and write the init function that connects the STDIO transport. Each pauses the recording with the brief as a comment in the file, and each carries Scrimba's Challenge with Instant Feedback icon. **Q: Do I need to install anything?** Not for the course itself; the server runs in Scrimba's built-in terminal. To repeat the MCP Inspector or Claude Desktop demos you need Node.js and the host app on your own machine. **Q: Does it cover streamable HTTP or remote servers?** Only in slides. The Transports lesson explains STDIO and streamable HTTP, and the Local vs Remote explainer covers the difference, but the code only uses STDIO. **Q: How long does it take?** About 47 minutes of video, or one and a half to two hours if you do the three challenges yourself. Add an hour to run it locally with Claude Desktop or Cursor. **Q: Does it have transcripts?** Yes. Every scrim has captions, a timestamped transcript in the settings menu, and subtitles in ten languages. ### Related Guides - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) - [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) - [Context Engineering](https://scrimbaguide.tech/docs/courses/ai/context-engineering/) - [MCP for JavaScript Developers](https://scrimbaguide.tech/blog/mcp-for-javascript-developers/) --- # Learn OpenAI's Assistants API Source: https://scrimbaguide.tech/docs/courses/ai/openaiassistants/ Scrimba's shortest AI course: about 30 minutes with Guil Hernandez, in which you turn a movie recommendation chatbot into an OpenAI "assistant" that answers from a text file. The course is clear and quick, but it runs on an API version OpenAI has since moved away from, so weigh that before you spend a Pro slot on it. Reviewed inside the course with a Pro account, September 2026. ## Quick answer This fits Pro subscribers who want the assistant, thread, message, and run vocabulary explained once, not people hunting for a project to build. The catch is age: the code targets OpenAI's original 2023 beta, a surface OpenAI has since replaced and marked for retirement. If you want the same ideas on current ground, start with [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) instead. **Learn OpenAI's Assistants API** Watch a movie chatbot get rebuilt on OpenAI's Assistants API in 30 minutes: assistant, thread, messages, run, and the polling loop that ties them together. - Duration: 30 min - Level: Intermediate - 9 lessons - Taught by [Guil Hernandez](https://scrimba.com/@Guilh?via=u42d4986) [View on Scrimba](https://scrimba.com/learn/openaiassistants?via=u42d4986) ## Is it worth your time? If you already pay for Pro and want to know what "threads" and "runs" mean before you meet them in someone else's code, yes. Thirty minutes is a fair price for that. Guil moves fast, explains each object the API returns, and shows the response in the console every time. By the end you can read any Assistants API codebase and know which call does what. If you are choosing what to spend an evening on, I would pick something else first. This is a screencast, not a workshop. Guil says so in the third scrim: "if you're not set up just yet, no worries. Feel free to kick back and watch for now and experiment with the examples on your own time." Nothing in the course checks your work. Scrimba's other AI courses, such as [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) and [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/), make you build. The bigger issue is that the API moved. The scrims were recorded in November 2023 (the timestamps in the console output say so), during the first beta. OpenAI later renamed the `retrieval` tool to `file_search`, replaced `file_ids` with vector stores, and in 2025 said the whole Assistants API would be retired in favor of its Responses API. I did not run the code with my own key, so I cannot tell you which of these exact calls still succeed today. What still holds is the mental model: a persistent conversation the provider stores for you, a file the provider indexes for you, and a job you poll until it finishes. That is the part worth 30 minutes. ## What you'll learn ### Course curriculum 9 scrims in a flat list on Scrimba; the three groups below are my own reading of the sequence - Module 1: What the Assistants API is (7 min, 2 lessons) - Module 2: Build ReelRecs: assistant, thread, messages, run, UI (23 min, 4 lessons) - Module 3: Wrap-up and Scrimba house scrims (4 min, 3 lessons) Scrimba's course page and its structured data both say nine lessons, which matches the nine scrims I counted; the scrim durations add up to about 33.5 minutes, of which 30.5 is Guil's teaching, so the "30 min" label is accurate for the course itself. The older version of this page said seven lessons, which is the count without the two Scrimba house scrims. ## Inside the course, scrim by scrim ### 1. What the Assistants API is (7 min, 2 scrims) The intro, "Introducing the Assistants API," is the free sample and a slide video rather than a coding scrim. Guil frames the API as RAG with the plumbing removed: "They've built RAG right into the Assistants API." If RAG is new to you, it stands for retrieval augmented generation, the pattern where you search your own documents and hand the matching text to the model. He also sets the expectation that matters most in hindsight, at 2:33: "keep in mind that it's still in beta and under active development." "How OpenAI Assistants work" covers the three tools an assistant can be given: code interpreter (Python in a sandbox), knowledge retrieval, and function calling. Then Guil walks through OpenAI's flow diagram: create the assistant, create a thread, add messages, run it. He ends by showing the ReelRecs chatbot from his embeddings course, built the long way with chunking, an embeddings model, and a vector database. The point of the next four scrims is to rebuild it with fewer steps. ### 2. Build ReelRecs (23 min, 4 scrims) The project is five files: `config.js`, `index.html`, `index.css`, `index.js`, and `movies.txt`, with one dependency, `openai@4.17.4`. Before anything runs you need your own OpenAI API key saved as an environment variable in Scrimba; the third scrim points you to a separate scrim on how to do that. "Create an Assistant" (5:32) is the densest lesson. Guil calls `openai.beta.assistants.create` with instructions ("You are great at recommending movies..."), a name, `tools: [{ type: "retrieval" }]`, the model, and a `file_ids` array. To get a file ID he uploads `movies.txt` with `openai.files.create`, using `fetch` because the scrim runs in a browser and cannot read a file system. The line worth remembering comes at 4:18: "once a file is uploaded and passed to the assistant, OpenAI will automatically chunk your document, index, and store the embeddings," and then, "That's more than half of the usual RAG process right there." "Create a Thread and Messages" (2:43) is short. A thread is "initiated by the user, and it's where the message history gets stored." He creates one, copies its ID into a variable, and adds a user message with `role: "user"` and the content "Can you recommend a comedy?". The assistant does not reply yet, and that is the setup for the next scrim. "Running Assistants" (5:44) introduces the piece that makes this API different from chat completions. As Guil puts it at 0:12, "A run is what makes the assistant read the thread and decide how to best answer the user's query by either calling certain tools or simply using the model." He creates a run, shows its status starting at `queued`, walks the lifecycle chart (queued, in progress, completed, expired, failed), retrieves the run to confirm it completed, then lists the thread's messages. ![Learn OpenAI's Assistants API, Running Assistants lesson: a code editor showing a chatbot's message reply pasted in as a comment.](https://scrimbaguide.tech/img/scrimba/openaiassistants/running-assistants-barbie-reply-lesson.webp) *Running Assistants at 4:28. The newest message sits at index 0, and the reply names Barbie and The Menu, both straight out of movies.txt, so retrieval is doing the work.* Screenshot of scrimba.com, taken by scrimbaguide.tech. "Bring it all together" (8:50) is the longest scrim and the one that teaches you something the docs did not. Guil wires the calls to a form: create a message from the input, create a run, list messages, put the newest one on the page. It fails. The reply is the user's own question echoed back, because the run has not finished when the messages are read. "This is where the Assistants API and threads currently gets a bit weird," he says at 3:45. ![Learn OpenAI's Assistants API, Bring it all together lesson: a chatbot preview echoing the user's own question back as the answer.](https://scrimbaguide.tech/img/scrimba/openaiassistants/reelrecs-run-lifecycle-echo-bug-lesson.webp) *Bring it all together hits its first bug at 3:44, because the page reads the thread before the run finishes: the run lifecycle stops being a diagram right here.* Screenshot of scrimba.com, taken by scrimbaguide.tech. The fix is a polling loop: retrieve the run, wait 1.5 seconds, check again, until the status is `completed`. Guil admits he improvised it: "the OpenAI API docs doesn't exactly provide any snippets or even tips about polling for updates, but I did manage to put together some code that works for our app." He then adds run-level instructions to strip the `[source]` annotations, keep answers short, and refuse off-topic questions. The final demo asks for a follow-up ("which ones are great for children?"), an ambiguous query ("the movie with the actress from Her"), a memory check ("do you remember my name?"), an off-topic question about the sun, and finally "something that gives an adrenaline rush." ![Learn OpenAI's Assistants API, Bring it all together lesson: the finished chatbot preview recommending a movie.](https://scrimbaguide.tech/img/scrimba/openaiassistants/reelrecs-finished-assistant-top-gun-lesson.webp) *About 50 lines of index.js produce the finished ReelRecs demo at 8:41, with the recommendation still tracing back to movies.txt.* Screenshot of scrimba.com, taken by scrimbaguide.tech. ### 3. Wrap-up and house scrims (4 min, 3 scrims) "More to explore" (1:02) is a slide with links into the docs: modify and delete assistants, modify threads and messages, create-and-run in one request, cancel a run. Guil signs off with "Thanks, and happy building." The remaining two scrims are not his. "Want to become a Scrimbassador?" is a two minute pitch for Scrimba's referral program by Per from Scrimba, and "How to Utilize Your Certificate" is the one minute LinkedIn nudge that closes most Scrimba courses. ## What a lesson feels like Every scrim is Guil narrating over the editor with the ReelRecs preview floating in front of it when he tests. The pattern is the same each time: copy a snippet from OpenAI's API reference, paste it into `index.js`, fill in the IDs, run it, read the returned object in the console, copy the ID you need into a variable. Because it is a scrim and not a video, you can pause at any point, click into the editor, and run his code with your own key, and the transcript panel under the settings menu gives you every line with timestamps. Subtitles come in ten languages. There are no challenge scrims in the list and no "Challenge with Instant Feedback" icons on any of them. The tone is relaxed; Guil's most-used word is "Alright." If you like Scrimba because it makes you type, this course will feel passive. If you want a fast, well-narrated walkthrough you can scrub through, it is exactly that. ## Free or Pro: exactly what is gated The first scrim, "Introducing the Assistants API," carries the SAMPLE badge and plays without Pro. That scrim is the slide intro with no code. The other eight scrims, including every build step, need Pro, and so does the Certificate of Completion listed at the end of the course. There are no Solo Project items in this course, so Pro is not gating an extra project here, just the course itself. Scrimba's Discord is not a Pro feature: the pricing page lists basic access under the free plan and the Pro-only channels under Pro. See [current plans](https://scrimba.com/our-pricing?via=u42d4986) for what Pro includes across the catalog. ## How long it takes The teaching runs 30.5 minutes. Watching once, pausing to read each returned object, takes about 45 minutes. If you set up your own OpenAI key in Scrimba's environment variables and run each step yourself, plan for 60 to 90 minutes, mostly spent waiting on runs and reading console output. If you then try to port the code to the current API, that is a separate afternoon and the course will not help you with it. ## Who it's for, and who should skip it Take it if you are already on Scrimba Pro, you know what `async`/`await` and `fetch` do, and you want the assistant, thread, message, and run vocabulary explained once, properly, by someone who shows the response objects. It also fits anyone maintaining an older codebase that still uses `openai.beta.assistants` and needs to understand it quickly. Skip it if you want to build something you will ship in 2026; start with [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) or [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/), which teach the same ideas on surfaces that are still current. Skip it too if you are new to JavaScript. The code is short but Guil assumes you can read an async function, a promise, and a nested object path like `data[0].content[0].text.value` without help. [View Learn OpenAI's Assistants API on Scrimba](https://scrimba.com/learn/openaiassistants?via=u42d4986) ## Prerequisites Working JavaScript, including `async`/`await` and `fetch`. An OpenAI API account with a key you can add to Scrimba's environment variables; the third scrim expects it and points to a setup scrim. Guil twice refers to his embeddings and vector databases course as the place ReelRecs came from, so having done [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) or something similar makes the "this replaces the vector database" argument land, but it is not required. ## Where it fits This is a standalone Pro course under Scrimba's AI topic, not part of the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/). On this site it sits at the applied end of the [AI courses catalog](https://scrimbaguide.tech/docs/courses/ai/), next to [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/), which teaches the manual pipeline this API was designed to hide, and [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/), which covers tool calling in a provider-neutral way. Read it as historical context for those two rather than as a prerequisite. ## Strengths and limits What it does well: it stays short and clear about its scope, Guil shows every object the API returns instead of describing it, the polling bug in the final scrim is a real lesson about asynchronous jobs that most tutorials skip, and the whole thing fits in a lunch break. Where it is limited: the code targets the November 2023 beta (`retrieval`, `file_ids`, `gpt-4-1106-preview`), OpenAI has since changed and then deprecated that API, there are no challenges or projects of your own, and you need your own OpenAI API key to run anything. Nothing about streaming, cost, or evaluation is covered. ## Related courses and comparisons - [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/), the manual version of what the Assistants API automates - [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/), tool calling and agent loops without the OpenAI-specific surface - [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/), the broader starting point - [Learn to Code with AI](https://scrimbaguide.tech/docs/courses/ai/to-code-with-ai/), [Intro to Mistral AI](https://scrimbaguide.tech/docs/courses/ai/mistral-ai/), and [Build Serverless AI Agents with Langbase](https://scrimbaguide.tech/docs/courses/ai/serverless-ai-agents-with-langbase/), the free AI courses - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/), if you want the full sequence **Q: Is Learn OpenAI's Assistants API free on Scrimba?** Only the first scrim, the slide introduction, is free (it carries the SAMPLE badge). The eight remaining scrims, including all four build steps, and the certificate need Scrimba Pro. **Q: How long is the course?** Nine scrims totalling about 33 minutes, of which 30.5 minutes is Guil Hernandez teaching; the last two scrims are Scrimba's referral pitch and certificate reminder. Budget 45 minutes to watch with pauses, or 60 to 90 minutes if you run every step with your own key. **Q: Who teaches it?** Guil Hernandez, who also teaches Scrimba's embeddings and vector database material; he refers back to it twice. The two closing scrims are voiced by Scrimba staff. **Q: What do you build?** ReelRecs, a one-input chatbot that recommends movies from a movies.txt file. You create an assistant with the retrieval tool, a thread, a user message, and a run, then wire it to a form with a polling loop that waits for the run to complete. **Q: Is the code still current?** No. It was recorded in November 2023 on the first beta, using the retrieval tool, file_ids, and gpt-4-1106-preview. OpenAI later replaced those with file_search and vector stores and has announced the Assistants API will be retired in favor of the Responses API. I did not run the code with my own key, so treat the calls as historical and the concepts as the takeaway. **Q: Do I need an OpenAI API key?** Yes, if you want to run anything. The third scrim tells you to add your key as an environment variable in Scrimba before starting and points to a setup scrim; without it you can still watch. **Q: Are there challenges or a solo project?** No. There are no challenge scrims, no quizzes, and no Solo Project items. It is a watch-and-follow screencast you can pause and edit. **Q: Does it have transcripts?** Yes. Every scrim has a timestamped transcript under the settings menu and subtitles in ten languages. ### Related Guides - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) - [Scrimba AI Courses](https://scrimbaguide.tech/docs/courses/ai/) - [Is Scrimba Free? Pro vs Free](https://scrimbaguide.tech/docs/pricing/pro-vs-free/) --- # Prompt Engineering for Web Developers Source: https://scrimbaguide.tech/docs/courses/ai/prompt-engineering-for-web-developers/ Prompt Engineering for Web Developers is Treasure Porth's Pro course on getting better output from ChatGPT, about 3.1 hours across three sections. You do not build an app: you rewrite weak prompts, paste ChatGPT's code into the editor, and run it. The technique still holds in 2026; the tool-specific detail, recorded in 2023 against ChatGPT and Google Bard, does not. Reviewed inside the course with a Pro account, September 2026: all 50 scrims opened and transcribed. This page is part of our [Scrimba AI courses](https://scrimbaguide.tech/docs/courses/ai/) catalog. It's a standalone course, not part of the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/). ## Quick answer It fits you if you already write some JavaScript and want a repeatable way to get better results out of ChatGPT. The catch is the age: the prompting habits transfer to any current model, but you will have to translate the tool-specific detail yourself. If you want to build AI into an app rather than prompt one well, go straight to [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) instead. **Prompt Engineering for Web Developers** Write better prompts, then use ChatGPT to generate, test, debug, convert and document code, and to prepare for interviews. - Duration: 3.1 hrs - Level: Intermediate - 3 modules - Taught by [Treasure Porth](https://scrimba.com/@trezp?via=u42d4986) [View on Scrimba](https://scrimba.com/prompt-engineering-for-web-developers-c02o?via=u42d4986) ## Is it worth your time? If you use ChatGPT for coding and your results are hit and miss, yes. The first section is a tight 80 minutes on the habits that make the difference. Say which language you want. Give context. Ask for a specific format. Break big requests into a list, and iterate instead of giving up. Treasure teaches each one with a bad prompt and a good prompt side by side, and the transcripts show the actual ChatGPT output for both, so you can see why the second one worked. It is a 2023 course. Treasure says on camera that she is recording in June 2023, ChatGPT's training data "stops in late twenty twenty one," and one scrim is built around Google Bard, which no longer exists under that name. The prompting habits transfer to any current model, but expect to translate the tooling. It also is not a course about building AI into apps: there is no API call, no SDK, no model provider. For that you want [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/). So: strong technique, thin on modern tooling, and the last section (job search) is useful mostly if you are interviewing soon. I would take section one in an evening, skim what you need from section two, and keep section three for when you are applying. ## What you'll learn ### Course curriculum 3 modules · 48 lessons - Module 1: Prompt Engineering (80 min, 18 lessons) - Module 2: AI Assisted Coding (66 min, 20 lessons) - Module 3: Using AI Language Models for Job Search (42 min, 10 lessons) Lesson counts are the scrims I counted in each expanded section in September 2026. Scrimba's section headers show 0/5, 0/4 and 0/2, which count only the challenge-style scrims. The course listing says 51 lessons: the 48 here, plus two Scrimba house scrims after the last section (a 1:18 "Scrimba Docs" promo and a 0:56 certificate scrim), plus the certificate itself. Every timed scrim adds up to the 80, 66 and 42 minutes shown. By the end you can write a prompt that gets code in the language and shape you asked for. You can break a feature into a numbered list a model can follow, get edge cases and tests for a function you wrote, and run a mock interview against it. The course does not promise more than that, and it delivers that much. ## Inside the course, module by module ### 1. Prompt Engineering (80 min, 18 scrims) ![Title card for Scrimba's Prompt Engineering for Web Developers course, with line-drawn illustrations of five people talking.](https://scrimbaguide.tech/img/scrimba/prompt-engineering-for-web-developers/chapter-01-prompt-engineering-title-card.webp) *Eighteen scrims teach specificity, context, format control, breaking tasks into steps, and iterating on a prompt.* The first five scrims are free samples. The welcome scrim sets expectations. Language models "are really only good at one thing, and that is guessing what word should come next," as Treasure puts it. She names the prerequisite in the same breath: "you should have some experience with JavaScript and React to be successful in this course." The intro scrim then lists the five strategies the section will cover: be specific, use technical terms, provide context, give examples, and iterate. Basics Part 1 and Part 2 show the pattern the whole course follows. "How do I center something?" gets a request for more context; "What's the best way to center a div element horizontally and vertically using CSS?" gets Flexbox and Grid with pros and cons. Then Treasure asks for a form that prints the user's input in reverse, pastes ChatGPT's HTML and JavaScript into the scrim, and runs it. A quiz scrim follows with three vague prompts for you to rewrite. ![Prompt Engineering for Web Developers, Basics Part 2 lesson: code editor beside a browser preview reversing typed text.](https://scrimbaguide.tech/img/scrimba/prompt-engineering-for-web-developers/reverse-text-form-prompt-lesson.webp) *Basics Part 2 at 2:32. The HTML came straight from ChatGPT, and the preview shows it running once the script tag is pointed at index.js, the one manual fix.* Screenshot of scrimba.com, taken by scrimbaguide.tech. The middle of the section is the useful part. Control the length and format (8:35, the longest scrim in the course) is about asking for the shape of the answer. Treasure asks for a two-step explanation, a comparison table of Grid and Flexbox, exactly three bullets on innerHTML, a text flowchart for a pull request, and pseudocode written as code comments. The line I now use most is "only include the code that needs to be modified." The Haiku-ish Generator challenge then has you improve three weak prompts until they produce working JavaScript, with a warning that ChatGPT counts syllables badly. Break Tasks Into Smaller Steps is the scrim I would send someone who is frustrated with AI code. Treasure tries to get a whole React budget tracker from one long prompt and gets an app with invisible progress bars and two ignored requirements. "You wouldn't throw all the bricks and all the mortar into a pile and smear it around," she says, and then rebuilds it component by component in a React 18.2 scrim. ![Prompt Engineering for Web Developers, Break Tasks lesson: code editor beside a preview of a budget tracker with colored bars.](https://scrimbaguide.tech/img/scrimba/prompt-engineering-for-web-developers/budget-tracker-break-tasks-lesson.webp) *The rebuilt budget tracker at 7:12, after a run of small prompts instead of one big one: the ProgressBar component on the left is ChatGPT's code with the final fix applied, width capped at 100%.* Screenshot of scrimba.com, taken by scrimbaguide.tech. Four more ideas fill out the section. Prompt Iteratively contrasts editing a prompt and regenerating with adding a follow-up, using a board game shop page that lost its Buy Now buttons on the rewrite. Optimize prompts has ChatGPT interview you about what you want before it writes the prompt, and the modal challenge makes you do the same for a React modal. Role-based prompting ("act as a product manager") plans a houseplant app from architecture advice down to Jira tickets; the practice scrim repeats it for a hotel booking MVP. Prompt with Examples shows that an example input and output beats a paragraph of description, and the Seltzer Flavor Generator challenge, with a full solution scrim, is built on that. Beware Hallucinating is a short story about ChatGPT inventing a slider library: "When I go to this GitHub link, I get a four zero four. It doesn't exist." The recap scrim ends with a markdown file of every good prompt from the section, which you can download as a zip. ### 2. AI Assisted Coding (66 min, 20 scrims) ![Title card for section 2 of Scrimba's Prompt Engineering for Web Developers course: AI Assisted Coding, on a light blue background](https://scrimbaguide.tech/img/scrimba/prompt-engineering-for-web-developers/chapter-02-ai-assisted-coding-title-card.webp) *Twenty scrims use ChatGPT to generate, test, debug, convert, and document code, from pseudocode to a jQuery-to-vanilla-JS conversion.* This section is a list of jobs and a prompt for each. Generate code with pseudocode shows two ways to describe a findBookById function in plain English and get the same JavaScript back. Generate code using a pseudo language goes further: Treasure asks ChatGPT to invent a markdown-like template for describing a React component, then uses it to generate a Counter and a NavBar. The follow-up challenge does the same for HTML forms. Her caveat is worth remembering: "ChatGPT's memory is short, and you may need to remind it of your template after every seven or ten interactions or so." Generate Edge Cases and Generate Test Cases are the two scrims most likely to change how you work. She asks for eight edge cases for a removeDupes function, gets them as a single copy-pasteable block of console.log tests, and discovers the function treats "T" and "t" as different characters. Then she generates Jest tests for an isEven function, asks for a browser-runnable version, and lets the failing string test drive a refactor. The practice scrim hands you a chunkArray function that will loop forever on a chunk size of zero and asks you to find that yourself. Debugging and Error Messages introduces a small trick I have started using. Ask for fixes "with code comments," then add "comment out the old code rather than replacing it so I can better see how you fixed it." Convert Code covers JavaScript to Python, CSS to Tailwind, CSV to JSON, and React to Vue. Its challenge gives you a rocket launcher written in jQuery and Tailwind and asks you to convert both so the countdown works. ![Prompt Engineering for Web Developers, Convert Code challenge: code editor beside a preview of a rocket launch countdown app.](https://scrimbaguide.tech/img/scrimba/prompt-engineering-for-web-developers/convert-code-rocket-challenge-lesson.webp) *The Convert Code challenge at 1:43, mid countdown. The CSS on the left is ChatGPT's conversion of the Tailwind classes, with the original class names kept as comments so you can check its work.* Screenshot of scrimba.com, taken by scrimbaguide.tech. The second half is lighter. Document Code asks for JSDoc and Storybook boilerplate, then has ChatGPT interview Treasure to produce a JavaScript style guide. Two Study Web Development scrims cover explanations by audience ("explain callbacks as if I am five"), study guides, and self-quizzing, with a warning that the model may invent sources. Explore APIs with Bard uses Google's model to query the GitHub API. Treasure spots that the "top five by stars" result is actually the first five returned, "a good lesson in staying vigilant." Get Help with Git and Github and Get Help Deploying are prompt lists rather than lessons. When to Step Back from AI names the failure mode: "copy paste and pray," where each fix introduces a new bug. The section ends with a recap and a Scrimba referral promo from Per Borgen. ### 3. Using AI Language Models for Job Search (42 min, 10 scrims) ![Title card for section 3 of Scrimba's Prompt Engineering for Web Developers course: AI for Job Search (and professional development)](https://scrimbaguide.tech/img/scrimba/prompt-engineering-for-web-developers/chapter-03-ai-for-job-search-title-card.webp) *Ten scrims use AI to study algorithms, review code for Big O, run mock interviews, and draft resume bullets and a pitch.* Section title cards from scrimba.com. Two DS/Algo scrims use the Two Sum problem to show a study loop: generate three easy problems, ask for a 150-word explanation, a metaphor, pseudocode "without giving away the answer," then brute force and optimized solutions. Treasure is direct about the limits: "these strategies work much better with ChatGPT four and beyond," and they suit easy to medium problems only. Part 2 covers pattern study (sliding window, two pointers). The FizzBuzz challenge has you solve it yourself, then ask for a review. Review and Analyze Code uses the same Two Sum solution to introduce Big O by asking for a code review and three solutions with different time complexities. The practice scrim gives you a working but ugly isPalindrome function and asks you to get it reviewed; the improved version handles negative numbers. Get Live Code Interview Advice has ChatGPT play both sides of an interview, first asking clarifying questions as the candidate, then answering them as the interviewer for "an entry level position." The last two long scrims are about documents and behavioral questions. Job Search Docs uses "act as a resume writing expert and ask me questions" to draft experience bullets, then tailors them to a pasted job ad and writes a 30-second pitch. Treasure's framing: AI is "a good starting place, but certainly not a destination" for a resume. Practice Interview Questions walks through the STAR method and an interview-coach prompt that gives feedback on your answers, including a deliberately wrong answer about accessibility. A one-minute congratulations scrim closes the course. ## What a lesson feels like Most scrims are three to six minutes. The screen is usually a slide with a prompt and ChatGPT's reply, then a cut to the editor where Treasure pastes the code in and runs it in the preview pane. Roughly every third scrim ends with "go ahead and pause the scrim now": you open your own ChatGPT tab, do the task, and come back for her prompts. Eleven scrims carry Scrimba's challenge icon, but the checking happens in your head and your ChatGPT window, not in the scrim. You will not type much. The code files are there so you can paste generated code and see it run, and a few scrims (the quiz, the recap, the study review) are just a markdown file. Captions, a full timestamped transcript under the settings menu, subtitles in ten languages, and playback speed are all there. Treasure's delivery is warm and unhurried, with the occasional aside ("Way to go, Bob") and a rhyme at the end of the haiku challenge. ## Free or Pro: exactly what is gated The first five scrims of section one are free previews: the welcome, the intro, Basics Part 1 and 2, and the quiz. Everything after that, 43 of the 48 lessons, needs Pro, as does the certificate. There are no Solo Projects in this course, so there is nothing else to unlock inside it. Pro also adds the Pro-only Discord channels; the basic Discord server is free on every plan according to Scrimba's pricing page, so that alone is not a reason to upgrade. See [current plans](https://scrimba.com/our-pricing?via=u42d4986) for what Pro costs in your region. ## How long it takes 3.1 hours is the runtime. If you only watch, that is an afternoon. If you pause at every "go ahead and pause" and do the work in ChatGPT, plan on seven to ten hours, because writing and reworking prompts takes longer than watching someone else do it, and section one alone has five challenges. Section three only pays off if you also solve the problems and run the mock interviews, so budget more if you are preparing for interviews now. ## Who it's for, and who should skip it It fits you if you already write some JavaScript, you use ChatGPT or a similar model for code, and you want a system for getting better results. It is also a decent read for a junior developer who wants a repeatable way to study algorithms and rehearse interviews without a partner. Skip it if you want to build with AI: no APIs are called here. Skip it if you have never written code, since every example assumes you can read the JavaScript and React that comes back. And if you already prompt well, with numbered requirements, examples, and follow-up questions, you will find the first section familiar and the rest a list of ideas you have probably had. [View Prompt Engineering for Web Developers on Scrimba](https://scrimba.com/prompt-engineering-for-web-developers-c02o?via=u42d4986) ## Prerequisites Basic JavaScript and a little React. The budget tracker, accordion, modal, counter and nav bar examples are all React components. Treasure says plainly that you should have "some experience with JavaScript and React." You need a free ChatGPT account, which she links in the scrims. One scrim in section two, Explore APIs with Bard, uses Google Bard, which you will have to substitute with a current model. You do not install anything, and there is no API key or paid AI plan to buy beyond Scrimba Pro. ## Where it fits This course is not part of the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/); it stands apart in the AI catalog as a workflow course, not an engineering one. The natural pairing is [Learn to Code with AI](https://scrimbaguide.tech/docs/courses/ai/to-code-with-ai/), Scrimba's free beginner on-ramp to building with ChatGPT, before this one; and [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) after it, once you want to put a model inside an app. Scrimba's free [Prompting chapter](https://docs.scrimba.com/how-ai-works/prompting?via=u42d4986) in its docs covers the same technique in text form and is model-agnostic, so it is worth reading alongside. ## Strengths and limits What it does well: - Every technique comes with a real prompt and the real reply. - The edge case, test, and debugging scrims give you habits you can use the same day. - The challenges are quick and low friction because nothing needs installing. - Treasure is candid about hallucination, forgetful models, and when to stop asking. Where it is limited: - It was recorded in June 2023 on ChatGPT and Google Bard. The model-specific facts (a 2021 training cutoff, Bard as the "up to date" option) are stale. - It never touches an API, an SDK, or a coding assistant in an editor. - The Git, deploy, and study scrims are prompt lists with little to do. - 43 of the 48 lessons sit behind Pro for a course you can finish in a weekend. ## Related courses and comparisons - [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/), if you want to build AI into apps instead - [Learn to Code with AI](https://scrimbaguide.tech/docs/courses/ai/to-code-with-ai/), the free beginner on-ramp - [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/), for AI that acts rather than assists - [Intro to Mistral AI](https://scrimbaguide.tech/docs/courses/ai/mistral-ai/), a free way to practise LLM app patterns - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/), where the engineering courses are sequenced **Q: Is Prompt Engineering for Web Developers free?** No. The first five scrims (welcome, intro, Basics Part 1 and 2, and the quiz) are free previews. The other 43 lessons and the certificate need Scrimba Pro. This course is not part of the AI Engineer Path. The free AI starting points are Learn to Code with AI and Intro to Mistral AI. **Q: Do I need an API key or anything installed?** No. Every exercise runs in the public ChatGPT interface, and you paste the generated code into the scrim's editor to check it. A free ChatGPT account is enough. One scrim in section two uses Google Bard, which you will need to replace with a current model. **Q: Is this about building AI apps?** No. It is about using ChatGPT to plan, generate, test, debug, convert and document code, and to prepare for interviews. No API is called anywhere in the course. For building AI features, see Intro to AI Engineering. **Q: Who teaches it?** Treasure Porth, a Scrimba instructor. She records every lesson herself; the only other voices are two short Scrimba house scrims at the end of the course. **Q: What do you actually do in the course?** Rewrite weak prompts, build a haiku generator, a React modal, and a seltzer flavor generator from prompts, generate edge cases and tests for small functions, convert a jQuery and Tailwind rocket launcher to plain JavaScript and CSS, solve FizzBuzz and get it reviewed, and run mock interviews. Eleven scrims carry Scrimba's challenge icon. **Q: Is it out of date?** Partly. It was recorded in June 2023 with ChatGPT (GPT-3.5 and 4) and Google Bard, and it mentions ChatGPT's 2021 training cutoff. The prompting techniques still work with current models; the tool-specific details do not. **Q: How long does it take?** 3.1 hours of video. Doing every pause-and-try exercise in your own ChatGPT tab brings it to seven to ten hours. Sections one and two can be done in a weekend; section three is best saved for when you are interviewing. **Q: Do I need to know React?** Some. Treasure says you should have experience with JavaScript and React, and most generated examples are React components (a budget tracker, an accordion, a modal, a nav bar). You read the code rather than write it, so a basic grasp is enough. **Q: Does it have transcripts or captions?** Yes. Every scrim has captions, a timestamped transcript under the settings menu, subtitles in ten languages, and playback speed control. The section one recap also includes a downloadable markdown file of the example prompts. ### Related Guides - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) - [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) - [AI Tools for Developers](https://scrimbaguide.tech/blog/ai-tools-every-developer-should-know-2026/) --- # Learn RAG Source: https://scrimbaguide.tech/docs/courses/ai/rag/ Learn RAG is Scrimba's Pro course on Retrieval-Augmented Generation: fetching text from your data and feeding it to a language model before it answers. Guil Hernandez teaches it in about 94 minutes and 22 scrims, from embeddings to a movie-recommendation chatbot on Supabase, the fastest route to retrieval if you already call the OpenAI API from JavaScript. Reviewed inside the course with a Pro account, September 2026: every scrim's transcript read and its code opened. This page is part of our [Scrimba AI courses](https://scrimbaguide.tech/docs/courses/ai/) catalog. Scrimba lists it under the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/). ## Quick answer Take it if you already call the OpenAI chat API from JavaScript: it is the most direct route to the retrieval half of that job. The course is Pro-only, in one flat list, with three AI-checked challenges and a Pro solo project called PopChoice at the end. If you have never sent a chat completion from code, start with [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/). **Learn RAG** Embeddings, a Supabase vector store, similarity search, chunking with LangChain, and a chatbot that answers from your own data. - Duration: 1.6 hrs - Level: Intermediate - 22 lessons - Taught by [Guil Hernandez](https://scrimba.com/@Guilh?via=u42d4986) [View on Scrimba](https://scrimba.com/learn-rag-c033?via=u42d4986) The course has no chapter title cards; every scrim opens straight into a slide or the editor. The two slides below are the closest thing to course artwork. ![Learn RAG, What are embeddings lesson: a slide showing a 2D scatter graph of word points.](https://scrimbaguide.tech/img/scrimba/learn-rag/what-are-embeddings-vector-graph-lesson.webp) *Lesson 2 at 3:12: words with similar meanings land close together in vector space. The whole idea of the course on one slide.* ![Learn RAG, PopChoice solo project brief: a slide of requirements next to a phone app mockup.](https://scrimbaguide.tech/img/scrimba/learn-rag/solo-project-popchoice-core-requirements.webp) *The PopChoice solo project brief at 1:35, with the Figma design on the right.* Slides from scrimba.com. ## Is it worth your time? Yes, if you fit the prerequisites, and they are real. Guil says it in the intro: he assumes you know JavaScript and asynchronous code and have already used the OpenAI chat completions API. By the fifth scrim you are writing an `async` callback inside `map` and wrapping it in `Promise.all`. Nobody explains what a promise is. What I liked is how little theory sits between you and a working pipeline. One six-minute slide lesson covers embeddings; after that, everything is code you run in the scrim. When cosine similarity comes up (the math that scores how close two embeddings are), Guil shows the formula, says "I don't know about you, but this makes my head spin," and pastes a SQL function from the Supabase docs instead. That is the right call for a 94-minute course. The code is old. The scrims pin `openai@4.11.1` and `langchain@0.0.167`, and the models are `text-embedding-ada-002` and `gpt-4`. A 44-second scrim after "Vector databases" has a Scrimba staffer "popping in from the future" because the Supabase package "has been superseded and deprecated." The fix is a right-click and "upgrade package," and he warns you will need to do that in each scrim. The RAG pattern itself is unchanged. ## What you'll learn Scrimba presents this course as one flat list of 22 scrims with no modules. The groupings below are mine, made from the titles and transcripts; durations are the sum of the scrims in each group. ### Course curriculum 5 modules · 22 lessons - Module 1: Embeddings (intro to first challenge) (21 min, 5 lessons) - Module 2: Vector database with Supabase (13 min, 4 lessons) - Module 3: Semantic search and chat completions (23 min, 3 lessons) - Module 4: Chunking, error handling, and the ReelRecs chatbot (31 min, 5 lessons) - Module 5: Solo project and wrap-up (10 min, 5 lessons) I counted 22 scrims plus a certificate entry in September 2026. Scrimba's header says 94 minutes and its structured data says 23 lessons; the listed durations add up to about 98 minutes. When other pages on this site say 1.6 hours or 23 lessons, that is Scrimba's number. ## Inside the course, section by section ### 1. Embeddings (21 min, 5 scrims) The intro is a three-minute video. It opens with Spotify in 2014 turning songs and listening history into vectors, then promises "an AI tool that replies to you based on custom data stored with vector embeddings." "What are embeddings?" is slides, and it is good. Guil defines an embedding as "placing one object into a different space": a piece of text becomes a long list of numbers, and texts with similar meaning get similar numbers. He spends most of the six minutes on the 2D graph: cat at (4.5, 12.2), feline at (4.7, 12.6), dog off in its own region, "building" far from all of them. "Set up environment variables" is 94 seconds of housekeeping. You see three ways to open Scrimba's environment-variable modal, then add `OPENAI_API_KEY` so `config.js` can read it with `process.env`. The client is created with `dangerouslyAllowBrowser: true`, which tells you the code runs in the scrim's browser sandbox, not on a server. "Create an embedding" is the first real code scrim. Guil pastes the Node example from OpenAI's docs, sends "hello world" to `openai.embeddings.create()`, and reads the response: four tokens used and an array of 1,536 floating-point numbers. Then he swaps the string for five podcast descriptions and gets five vectors back in one request. The first challenge follows. It is the first of three scrims with Scrimba's "Challenge with Instant Feedback" icon, which means an AI checks your solution against the brief. The brief: for each text input, build an object with `content` and `embedding` properties. Guil's solution is `map` with an async callback inside `Promise.all`, and "if your solution looked a bit different than mine, that's totally okay." ![Learn RAG, Pair text with embedding challenge: code editor beside a console printing embedding results.](https://scrimbaguide.tech/img/scrimba/learn-rag/pair-text-with-embedding-challenge-lesson.webp) *The first challenge at 2:49, after Guil runs his solution. The console shows the five content-plus-embedding objects.* Screenshot of scrimba.com, taken by scrimbaguide.tech. ### 2. Vector database with Supabase (13 min, 4 scrims) "Vector databases" is a short slide explainer. Traditional databases match exact values; a vector store finds rows whose embeddings are close to yours. Guil name-checks Chroma, Pinecone, and Supabase, then picks Supabase, a hosted Postgres service that gains vector search through the pgvector extension. The 44-second dependency warning comes next. "Set up your vector database" is a walkthrough of supabase.com. You sign in with GitHub, create a free project, and enable the `vector` extension. Then you copy the project URL and API key into two more environment variables, `SUPABASE_URL` and `SUPABASE_API_KEY`. "Store vector embeddings" gives the database a table. The scrim ships `documents.sql`, six lines for the SQL editor: `id bigserial primary key`, `content text`, and `embedding vector(1536)`. The content is ten fictional podcast descriptions "that AI models like ChatGPT have no prior knowledge of," so any correct answer later must have come from your data. Guil inserts one row per `map` iteration first, to show that object keys must match column names, then refactors to a single batch `insert(data)`. "Fingers crossed," and ten rows appear in the table editor. ### 3. Semantic search and chat completions (23 min, 3 scrims) This is the core of the course. "Semantic search" is a five-minute concept scrim built on three phrases: "dogs are loyal companions," "books contain a world of knowledge," and "canines are faithful friends." You group the first and third by meaning without a shared word. That is the gap between lexical search (matching words) and semantic search (matching meaning), illustrated again with Spotify podcast search. "Query embeddings using similarity search" is nearly ten minutes and the one I would point a skeptic at. Guil sets the query to "jamming in the big easy," embeds it, and needs a way to compare it against the table. pgvector "makes the comparison and processing of vectors easy and fast with a SQL function that you can copy right from the docs." That function is `match_documents`, walked through line by line. A 1,536-dimension query vector goes in; id, content and a similarity score come out. It uses cosine distance because "that is what OpenAI recommends we use on their embeddings." Back in JavaScript, you call it through `supabase.rpc('match_documents', { query_embedding, match_threshold, match_count })`, with threshold 0.50 and count 1. The jazz query returns the New Orleans podcast at roughly 85 percent similarity despite sharing no words with it. Then the useful part. "Training puppies" returns a whale-song episode at about 75 percent, because the search "will still attempt to find the closest match based on the semantic relationships, even if contextually they're unrelated." That minute explains why the threshold exists. "Create a conversational response using OpenAI" adds `getChatCompletion`. The system prompt survives to the end of the course: "an enthusiastic podcast expert" that must answer from the context and say "Sorry, I don't know the answer" rather than invent one. The user message is `Context: ${text} Question: ${query}`, sent to `gpt-4` with temperature 0.5 and frequency penalty 0.5. "Something peaceful and relaxing" now gets a paragraph about a 30-minute silence podcast, and "training puppies" gets the refusal. ### 4. Chunking, error handling, and the ReelRecs chatbot (31 min, 5 scrims) "Chunking text from documents" is the LangChain lesson and, at 9:36, the longest scrim. Chunking means cutting a long document into short pieces before embedding each one. The embedding model "accepts a maximum of 8,191 tokens," and embedding several paragraphs at once "might miss out on important nuance details." On `podcasts.txt`, Guil imports `CharacterTextSplitter`, sets `chunkSize: 150` and `chunkOverlap: 15`, and gets 50 chunks; with overlap at zero, 47. `RecursiveCharacterTextSplitter`, which tries to keep sentences together, gives 78. His rule: "if the chunked text makes sense to a human without surrounding context, it will likely make sense to the language model." ![Learn RAG, Chunking text lesson: a code editor configuring the LangChain text splitter.](https://scrimbaguide.tech/img/scrimba/learn-rag/chunking-text-langchain-splitter-lesson.webp) *The splitter configuration at 5:53, just after Guil sets the overlap to 15 characters.* Screenshot of scrimba.com, taken by scrimbaguide.tech. The second AI-checked challenge combines everything so far. Split `movies.txt`, twelve films from 2022 and 2023 with rating, synopsis, and cast; embed every chunk; insert them into Supabase. Guil's solution uses the recursive splitter at 250 and 35, creates a `movies` table, and writes the `match_movies` function in the same SQL query. "Error handling" is three minutes of `try`/`catch`. You check `response.ok` on the fetch, log and rethrow from `splitDocument` so the caller stops, and throw on the `error` that Supabase returns from an insert. He proves it with a typo in the file name and reads the error chain in the console. "Query database and manage multiple matches" is the third AI-checked challenge. After switching the RPC to `match_movies` and the prompt to "an enthusiastic movie expert," Guil asks "which movie can I take my child to?" and gets The Super Mario Bros. Movie. The challenge: return at least three matches and combine them into one string. His solution sets `match_count` to 4 and joins the `content` fields with a newline. Two more queries show retrieval working. "I feel like having a good laugh" returns Glass Onion and Barbie. "The movie with that actor from Cast Away" returns Asteroid City, because the chat model already knows Tom Hanks and the database supplied the cast list. "AI chatbot proof of concept" wires the pipeline to a search form and a reply paragraph. Guil types "I like airplanes" and gets Top Gun: Maverick. Then he shows the limitation: ask a follow-up and "the AI draws a blank because it has no memory or context of previous interactions." The fix is to push each assistant reply onto `chatMessages` so the history travels with every request. After that it remembers his name and his taste for action films. This memory resets on refresh; long-term memory is "another course." ![Learn RAG, AI chatbot proof of concept: a chat preview showing the ReelRecs bot's movie reply.](https://scrimbaguide.tech/img/scrimba/learn-rag/ai-chatbot-proof-of-concept-reelrecs-lesson.webp) *The finished ReelRecs chatbot at 4:17, answering from the movies table after Guil tells it his name and that he likes action movies. The reply continues below the fold of the preview pane.* Screenshot of scrimba.com, taken by scrimbaguide.tech. ### 5. Solo project and wrap-up (10 min, 5 scrims) "Solo Project: PopChoice" is a four-and-a-half-minute brief voiced by a different Scrimba presenter. The app asks three questions (favorite movie and why, new or classic, fun or serious), combines the answers into one string, embeds it, searches the database, and explains why the match fits your mood. Core requirements are on the slide above. Any framework is allowed, "including React," or plain JavaScript. Stretch goals include a start screen for several people in one movie night, chunking the provided `movies.txt` instead of using the array, and pulling posters from a linked API. Hints are linked, and `config.js` comes set up for OpenAI and Supabase. The remaining four scrims are housekeeping and none is by Guil. Two are pitches: Scrimba's free docs site and Per Borgen's Scrimbassador referral program. The other two are the "You made it to the finish line!" recap and the standard "How to Utilize Your Certificate" scrim. You can skip all four without missing anything about RAG. ## What a lesson feels like Scrims run from 44 seconds to just under ten minutes. Four are slide videos with no files; the rest open on a small project: `config.js` for the API clients, `index.js` for the lesson code, and a data file. Guil talks over the editor, runs the code, and reads the console, which is where most of the teaching happens. Scrims autoplay when opened, so have a finger on pause if you want to read the code first. Challenges are written as comments in the file. Every scrim has captions, a timestamped transcript under the settings menu, and subtitles in ten languages. Guil's voice is calm and unhurried; "before I send you running off for the hills with this mathematical beast" tells you the tone. ## Free or Pro: exactly what is gated The first five scrims (intro through the first challenge, about 21 minutes) carry a SAMPLE badge and can be previewed without a subscription. Everything from "Vector databases" onward needs Pro. That covers the Supabase setup, similarity search, chunking, the two later challenges, the ReelRecs chatbot, the PopChoice project with its Figma file and hints, and the certificate. Pro also covers the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) this course sits in and the Pro-only channels on Scrimba's Discord; basic Discord access is listed as free. See [current plans](https://scrimba.com/our-pricing?via=u42d4986) for what Pro costs in your region. ## How long it takes The 94 minutes is video runtime. Budget three to four hours: the challenges take longer than their scrims, the Supabase setup happens on another site, and you will be upgrading the deprecated package in each scrim. PopChoice done properly from the Figma file adds four to eight hours. Call it a weekend for the course and a second one for the project. ## Who it's for, and who should skip it It fits JavaScript developers who already call the OpenAI chat API and now need the retrieval side, such as documentation assistants and support bots. It is also the course to take if you want pgvector on Supabase specifically. Skip it, for now, if `async`/`await` and `Promise.all` are shaky, or if you have never sent a chat completion from code; do [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) first. Skip it if you need Python, a dedicated vector database such as Pinecone, or production concerns like re-ranking and evaluation; none of that is here. LangChain appears only as its text splitters. [View Learn RAG on Scrimba](https://scrimba.com/learn-rag-c033?via=u42d4986) ## Prerequisites Comfortable JavaScript including asynchronous code, and prior experience with the OpenAI API and chat completions. No prior knowledge of embeddings, vector databases, SQL, or Supabase is assumed. You will need an OpenAI API key with billing enabled and a free Supabase account. ## Where it fits This is the retrieval course on the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/), between the fundamentals and the agent work. The history handling in the last lesson leads into [Learn Context Engineering](https://scrimbaguide.tech/docs/courses/ai/context-engineering/), and grounded retrieval is what makes the tools in [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) trustworthy. For the concepts in written form, Scrimba's docs have a free [RAG chapter](https://docs.scrimba.com/how-ai-works/rag?via=u42d4986). ## Strengths and limits What it does well: a complete RAG pipeline in under two hours of video. The similarity-search lesson shows both the hits and the false match, so you understand thresholds. The chunking lesson gives concrete numbers (50 vs 47 vs 78 chunks) rather than hand-waving. The challenges are AI-checked, and the solo project is a real portfolio piece with a design file. Where it is limited: the scrims pin `openai@4.11.1` and `langchain@0.0.167`, so package and model names need translating to current ones. It covers one vector store and one embedding provider, and it stops at a proof of concept with in-memory chat history. ## Related courses and comparisons - [All AI courses](https://scrimbaguide.tech/docs/courses/ai/), the category this course belongs to - [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/), the fundamentals to take first - [Intro to Mistral AI](https://scrimbaguide.tech/docs/courses/ai/mistral-ai/), a free course that touches on RAG - [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/), where grounded retrieval makes agents reliable - [Learn Context Engineering](https://scrimbaguide.tech/docs/courses/ai/context-engineering/), the follow-up on what goes in the prompt - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/), the path this course is sequenced into **Q: Is Learn RAG free on Scrimba?** No. It is a Pro course. The first five scrims (about 21 minutes, up to and including the first challenge) are marked SAMPLE and can be previewed; the Supabase setup, similarity search, chunking, the chatbot, the PopChoice solo project, and the certificate need a subscription. **Q: What do you build in Learn RAG?** A pipeline that embeds text with OpenAI, stores the vectors in a Supabase table with pgvector, finds matches with a match_documents SQL function, and sends the matched text to the chat model. The last lesson turns it into ReelRecs, a small movie-recommendation chat with conversation memory. The Pro solo project is PopChoice, a mobile-style app that recommends a film from your answers. **Q: Who teaches Learn RAG?** Guil Hernandez teaches every lesson except a handful of short ones voiced by other Scrimba staff: the PopChoice brief, the 44-second dependency warning, and the housekeeping scrims at the end. His teacher card describes him as a developer and educator who works with Python, JavaScript, and agentic AI, with a long tenure at Treehouse. **Q: Do I need an API key or any accounts?** Yes, two. An OpenAI API key with billing enabled, stored as a Scrimba environment variable, and a free Supabase project where you enable the vector extension and paste a SQL function into the SQL editor. Nothing is installed on your machine; the code runs in the scrims. **Q: Is the course out of date?** Partly. The scrims pin openai 4.11, langchain 0.0.167, text-embedding-ada-002 and gpt-4, and a warning scrim tells you to upgrade the deprecated Supabase package in every scrim you touch. The RAG pattern it teaches is unchanged; expect to translate a few package and model names to current ones. **Q: What are the AI challenges?** Three scrims carry Scrimba's Challenge with Instant Feedback icon: pairing each text with its embedding, splitting movies.txt and inserting the chunks into Supabase, and returning several matches from the database and combining them into one string. An AI checks your solution against the brief even if your code differs from Guil's. **Q: How long does Learn RAG take?** 94 minutes of video. Plan on three to four hours for the lessons and challenges including the Supabase setup, and another four to eight hours if you build PopChoice from the design file. **Q: Does it use LangChain?** Only for chunking. One lesson uses CharacterTextSplitter and RecursiveCharacterTextSplitter from langchain@0.0.167 with a 150-character chunk size and 15-character overlap, and the challenge that follows uses 250 and 35. The embeddings, database calls, and chat requests use the OpenAI and Supabase clients directly. **Q: Does the course have transcripts or subtitles?** Yes. Every scrim has captions, a timestamped transcript panel under the settings menu, and subtitles in ten languages. ### Related Guides - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) - [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) - [Scrimba AI Courses](https://scrimbaguide.tech/docs/courses/ai/) --- # Build Serverless AI Agents with Langbase Source: https://scrimbaguide.tech/docs/courses/ai/serverless-ai-agents-with-langbase/ Maham Codes's free Build Serverless AI Agents with Langbase course runs 49 minutes across 13 scrims, and it builds one thing: a support agent that retrieves answers from an uploaded FAQ file using the Langbase SDK in TypeScript. It is a clean, complete RAG loop in under an hour, though everything you learn runs through Langbase's own methods. Reviewed inside the course with a Pro account, September 2026. ## Quick answer This fits you if you already know what retrieval-augmented generation (RAG) is and want to see the full loop, chunking, embedding, retrieval, and generation, working end to end without setting up a vector database. The catch is that every concept runs through a Langbase method, so if Langbase is not part of your plans, take the transferable mental model to [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) instead. **Build Serverless AI Agents with Langbase** Build a RAG support agent in TypeScript with the Langbase SDK: memory, document upload, retrieval, an agent pipe, and grounded answers with sources. - Duration: 49 min - Level: Intermediate - 13 lessons - Taught by [Maham Codes](https://scrimba.com/@MahamDev?via=u42d4986) [Start free on Scrimba](https://scrimba.com/build-serverless-ai-agents-with-langbase-c0cg73hgmh?via=u42d4986) ## Is it worth your time? Yes, if you already know what RAG is and want to see one working in under an hour. The build is small but real. By scrim 9 you type one command, `npx tsx index.ts`, and the console prints an answer to "How do I upgrade my individual plan?" that is grounded in the FAQ file you uploaded, with the source cited. Nothing is skipped over: every step is a file you create and a command you run. The caveat is that this is a Langbase course first and an agents course second. The concepts (chunking, embeddings, top-k retrieval, system prompts) are explained well, but every one of them is used through a Langbase method: `memories.create`, `memories.documents.upload`, `memories.retrieve`, `pipes.create`, `pipes.run`. If Langbase is not in your plans, the transferable part is the mental model, which you can also get from [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/). The second caveat is setup. Before the first coding scrim you need a Langbase account, a Langbase API key stored in Scrimba's environment variables, and an LLM provider key added inside Langbase Studio (the course embeds documents with OpenAI's text-embedding-3-large). The course tells you this, but only in passing, so budget fifteen minutes for it. ## What you'll learn Scrimba presents this course as one flat list of 13 scrims with no sections. The grouping below is mine, so you can see how the time is spent. ### Course curriculum 13 scrims in one flat list, grouped here for readability - Module 1: Orientation: what you are building and how to run code (10 min, 3 lessons) - Module 2: Build the memory: create, upload, understand (15 min, 3 lessons) - Module 3: Retrieve and generate: the RAG loop (15 min, 3 lessons) - Module 4: Beyond the build: AI primitives and Command.new (10 min, 2 lessons) - Module 5: Scrimba house scrims: referral program and certificate (3 min, 2 lessons) The 13 scrims add up to 52 minutes 48 seconds; take away the two Scrimba house scrims at the end and it is 49 minutes 53 seconds, which is the 49 minutes shown in the course header. Scrimba's listing and structured data say 19 lessons, which counts the clips inside scrims rather than the scrims you click; 13 is what you will see in the table of contents. ## Inside the course, scrim by scrim ### 1. Orientation (10 min, 3 scrims) ![Title card of Scrimba's Build Serverless AI Agents with Langbase course, teacher Maham Codes, on a purple and olive gradient.](https://scrimbaguide.tech/img/scrimba/build-serverless-ai-agents-with-langbase/chapter-1-building-serverless-ai-agents-title-card.webp) *This module defines agentic RAG and Langbase's pipes and memory agents, then sets up the API key in Scrimba's environment variables.* The intro is the free preview scrim. Maham sets out the premise in one sentence: "AI agents without frameworks, and these agents are going to be context aware." She then defines an agent as "autonomous software powered by LLMs that can perceive, reason, decide, and act," names the prerequisites (JavaScript and TypeScript, with a pointer to [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/)), and tells you to sign up on Langbase and get an API key, because "we'll need it for the upcoming lessons." Core Concepts is a four minute slide lesson that defines agentic RAG and Langbase's two main building blocks. Pipes are "serverless AI agents that run online"; memory agents are "AI agents with human like long term memory." The useful part is the last minute, where she walks the full pipeline you are about to build: create a memory, upload data, retrieve chunks for a question, pass them to a pipe, return the answer. Setting Up Environment Variables in Scrimba is the practical bridge. You add your Langbase key in Scrimba's settings under "scrim environment" and read it as `process.env.LANGBASE_API_KEY`. She also tells you how every code scrim will run: `npm install`, then `npx tsx filename.ts` in the terminal. ### 2. Build the memory (15 min, 3 scrims) ![Title card of the Create a Memory with Langbase SDK scrim in Scrimba's Build Serverless AI Agents with Langbase course](https://scrimbaguide.tech/img/scrimba/build-serverless-ai-agents-with-langbase/chapter-2-create-a-memory-title-card.webp) *This module creates a Langbase memory, uploads the FAQ file to it, then explains the parse, chunk, embed and index pipeline behind that upload.* Title cards from scrimba.com. Create a Memory with Langbase SDK is the first coding scrim and the first challenge. You watch her create `create-memory.ts`, import `dotenv/config` and `Langbase`, and instantiate the client. Then the recording pauses: "Create a memory named knowledge base using the memories dot create method and use OpenAI text embedding three large model for embeddings. Finally, log the created memory to the console." The solution is eleven lines. When she runs it, the console prints the new memory with a chunk size of 10,000 and an overlap of 2,048, and it appears in the Memory tab of Langbase Studio. ![Build Serverless AI Agents with Langbase, Create a Memory challenge: a code editor sits above an empty terminal waiting for the run.](https://scrimbaguide.tech/img/scrimba/build-serverless-ai-agents-with-langbase/create-memory-challenge-brief-lesson.webp) *The first challenge at 3:02. The brief is a comment in create-memory.ts, the header switches to Exercise 1 with a CHECK SOLUTION button, and the terminal waits for your npx tsx run.* Screenshot of scrimba.com, taken by scrimbaguide.tech. Upload Documents to AI Memory is the longest scrim at six and a half minutes and the second challenge. You create a `docs` folder with a mock `langbase-faq.txt`, read it with `readFile` and `path.join`, and call `memories.documents.upload` with a content type, a document name, the file contents, and optional `meta` tags. The challenge is to finish the upload call and print a success message. She notes that Langbase accepts text, PDF, markdown, and CSV. Memory Agents on Langbase is a slide lesson with no code, and it is the best explanation in the course. She walks through what happens after upload: parse, chunk, embed, index. Her line on embeddings is the one to remember: "an embedding is basically a numerical representation of the meaning." She then covers the query side, where Langbase can rewrite the query, retrieve, rerank, generate, and evaluate. ![Build Serverless AI Agents with Langbase, Memory Agents lesson: a hand-drawn diagram traces data from upload to a vector store.](https://scrimbaguide.tech/img/scrimba/build-serverless-ai-agents-with-langbase/memory-agents-after-document-upload-pipeline-slide.webp) *The After Document Upload slide at 0:41: parse, chunk, embed, index. This is the diagram she narrates for the next minute and a half.* Screenshot of scrimba.com, taken by scrimbaguide.tech. ### 3. Retrieve and generate (15 min, 3 scrims) Perform RAG Retrieval starts in Langbase Studio, where a "retrieval testing" panel lets you type a question and see chunks come back with similarity percentages. Then the code: an `agents.ts` file exporting `runMemoryAgent(query)`, which calls `memories.retrieve` with the query, `topK: 4`, and the memory name, and an `index.ts` that prints the chunks. Her tip: "You can adjust chunk size and overlap under the settings to improve retrieval accuracy." Create an AI Agent Pipe is the third challenge. You create `create-pipe.ts` and define a pipe with `pipes.create`: a name, a description, and a `messages` array holding the system prompt. She explains the system prompt as "giving the AI its job description before the conversation starts." The challenge is to write that definition yourself; the solution names it `ai-support-agent` with a two sentence system prompt. Generate RAG Responses closes the loop. Back in `agents.ts` you add `runAiSupportAgent(chunks, query)`, which builds a system prompt from the chunk text (rules: be helpful, use only the given context, always cite sources) and calls `pipes.run` with `stream: false`. `index.ts` now chains the two functions. She runs it and ends with: "You just build a retrieval augmented generation rag agent, and it first retrieves relevant info from memory, then it uses that info to answer questions accurately. And it always cites its sources." ![Build Serverless AI Agents with Langbase, Generate RAG Responses lesson: the terminal prints the finished agent's grounded answer.](https://scrimbaguide.tech/img/scrimba/build-serverless-ai-agents-with-langbase/generate-rag-responses-npx-tsx-output-lesson.webp) *The finished agent at 5:06. index.ts on top is the whole program; the terminal below is the grounded answer to the billing question, assembled from the chunks retrieved from memory.* Screenshot of scrimba.com, taken by scrimbaguide.tech. ### 4. Beyond the build (10 min, 2 scrims) AI Primitives for Context Engineering is a tour of the rest of Langbase's catalog: Workflow, Threads, Parser, Chunker, Embed, Tools, and Agent, plus eight reference architectures with names like "prompt chaining" and "evaluator optimizer." It is a slide lesson with no code and reads like a product overview. It does contain one good pointer, to Scrimba's [Intro to Model Context Protocol](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/) course, which Maham also teaches. Vibe Coding AI Agents with Command.new is a six minute screen recording of Langbase's Command tool. You type "build an AI support agent that uses my docs as memory for autonomous RAG" and it generates the agent code, a React front end, a memory, and a deployable API. This is the same agent you just built by hand, generated in a minute, and she is candid that the point of the manual build was understanding: "we'll be building the back end step by step so you can understand exactly what's happening behind the scenes." ### 5. Scrimba house scrims (3 min, 2 scrims) The last two scrims are not part of the course content. Per Borgen of Scrimba pitches the Scrimbassador referral program, then a 53 second scrim tells you to put your certificate on LinkedIn. Both appear at the end of many Scrimba courses. ## What a lesson feels like Every scrim is between one and six and a half minutes. Five of the thirteen are slide lessons with no code (intro, Core Concepts, environment variables, Memory Agents, AI Primitives), one is a screen recording of a third-party site (Command.new), and five are coding scrims where you can pause, edit the file, and run it in Scrimba's built-in terminal. The three challenges follow the same pattern: she demonstrates a method, states the task in one sentence, and says "I'll pause here so you can do it on your own," then walks through the solution. The code is small. The longest file, `upload-docs.ts`, is 31 lines. Because the scrims are so short, the transcript panel is more useful here than in most courses: you can read a scrim's transcript in a minute to decide whether you need to watch it. Captions, playback speed, and subtitles in ten languages are all there. One thing to know: the challenges only work if your keys are set up. If you skipped the environment variables scrim, the first `npx tsx` will fail on a missing API key, and the course does not show you that error. ## Free or Pro: exactly what is gated All 13 scrims and all three challenges are free; the course sits in the Free tab of Scrimba's catalog and its structured data marks it free. There are no Solo Projects in this course, so nothing inside it is locked behind Pro. What Pro adds around it: the Certificate of Completion listed at the end of the table of contents, and the Pro-only Discord channels (basic Discord access is free). This course is not part of the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/); see [current plans](https://scrimba.com/our-pricing?via=u42d4986) if that path is what you want. Separately from Scrimba, you need a Langbase account and an LLM provider key for the code to run. I did not test what Langbase's free tier covers, so check that before you start. ## How long it takes Video runtime is 49 minutes. Plan for two to three hours: fifteen minutes of setup (Langbase account, API keys, Scrimba environment variables), around an hour to type along with the five coding scrims and do the three challenges yourself, and time to poke at the retrieval testing panel with your own questions. If you swap the mock FAQ for a document of your own, which is the obvious next step, add another hour. ## Who it's for, and who should skip it It fits you if you can write basic TypeScript, you know what an LLM API call looks like, and you want to see a full RAG agent run in one sitting. It also works as a first look at Langbase if you are evaluating it against a framework. Skip it if you have never called an LLM from code; [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/) is the right start. Skip it if you want platform-neutral agent design; [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/) covers tool calling and agent loops without tying you to a vendor. And if what you want is to understand RAG itself, [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) goes deeper on chunking and embeddings than this course has room for. [Start Build Serverless AI Agents with Langbase for free](https://scrimba.com/build-serverless-ai-agents-with-langbase-c0cg73hgmh?via=u42d4986) ## Prerequisites Basic JavaScript and TypeScript (async functions, imports, reading a file). Maham says so in the intro and recommends [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) if you are not there yet. You also need to be comfortable running commands in a terminal, because every coding scrim ends with `npx tsx`. No prior agent or RAG experience is assumed; Core Concepts and Memory Agents cover the ideas before you use them. ## Where it fits This course stands outside the [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/). It pairs naturally with [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/) (the concepts) and [Learn Context Engineering](https://scrimbaguide.tech/docs/courses/ai/context-engineering/) (the broader practice the course keeps referring to). For a contrasting agent build on a different SDK, [Build a Support Agent with Vercel AI SDK](https://scrimbaguide.tech/docs/courses/ai/a-support-agent-with-vercel-ai-sdk/) builds a similar support agent with more decision logic. Maham's other Scrimba course, [Intro to Model Context Protocol](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/), is the one the AI Primitives scrim points you to. ## Strengths and limits What it does well: a complete RAG agent in five short coding scrims, each step a file you can read in a minute; three challenges that are small enough to finish; the Memory Agents lesson, which explains parse, chunk, embed, and index more clearly than many longer courses. Where it is limited: everything is expressed through the Langbase SDK, so little of the code transfers elsewhere; two of the eleven content scrims are product tours (AI Primitives, Command.new); setup outside Scrimba is required and only lightly explained; and it does not touch tools, workflows, or threads in code, only on slides. ## Related courses and comparisons - [Learn AI Agents](https://scrimbaguide.tech/docs/courses/ai/ai-agents/), the broader, platform-neutral agent course - [Learn RAG](https://scrimbaguide.tech/docs/courses/ai/rag/), the concepts behind chunking, embeddings, and retrieval - [Build a Support Agent with Vercel AI SDK](https://scrimbaguide.tech/docs/courses/ai/a-support-agent-with-vercel-ai-sdk/), a contrasting agent build - [Intro to Model Context Protocol (MCP)](https://scrimbaguide.tech/docs/courses/ai/model-context-protocol-mcp/), also taught by Maham Codes - [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/), the underlying fundamentals - [Intro to Mistral AI](https://scrimbaguide.tech/docs/courses/ai/mistral-ai/), another free AI course **Q: Is Build Serverless AI Agents with Langbase free on Scrimba?** Yes. All 13 scrims, including the three challenges, are free with no Pro subscription. Pro only adds the certificate and the Pro-only Discord channels; this course is not part of the AI Engineer Path. You do need a separate Langbase account and an LLM provider key for the code to run. **Q: What do you build in the course?** One project: a support agent that answers questions from a mock FAQ text file. You create a Langbase memory, upload the document, retrieve the four most relevant chunks for a question, create an agent pipe with a system prompt, and connect them so the agent answers with sources cited. It runs from the terminal with npx tsx. **Q: Who teaches it?** Maham Codes (@MahamDev), who describes herself in the intro as an AI content developer and also teaches Scrimba's Intro to Model Context Protocol course. The two closing scrims are Scrimba house content from Per Borgen. **Q: How many lessons does it have?** 13 scrims in one flat list, no sections. Scrimba's listing says 19 lessons because it counts the clips inside scrims. Five scrims are slide lessons, five are coding scrims, one is a screen recording of Command.new, and two are Scrimba's standard closing scrims. **Q: Are there challenges?** Three, each marked with Scrimba's Challenge with Instant Feedback icon: create the memory, upload the document, and define the agent pipe. Each is stated in one sentence, the recording pauses, and the solution follows. **Q: What do I need to install or sign up for?** A Langbase account and API key, stored as LANGBASE_API_KEY in Scrimba's environment variable settings, plus an LLM provider key added in Langbase Studio (the course embeds with OpenAI's text-embedding-3-large). Inside Scrimba nothing else is installed; each coding scrim runs npm install and npx tsx in the built-in terminal. **Q: How long does it take?** 49 minutes of video. Plan two to three hours including account setup, typing along with the five coding scrims, and doing the three challenges yourself. **Q: Does it have transcripts?** Yes. Every scrim has captions, a timestamped transcript panel, playback speed control, and subtitles in ten languages. The transcripts are a fast way to skim the slide lessons. **Q: How does it compare to Learn AI Agents?** This is a short, Langbase-specific RAG build. Learn AI Agents is longer and platform-neutral, covering tool calling and agent loops. Take this one to see a memory-backed agent work quickly, and the other to learn agent design you can apply anywhere. ### Related Guides - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) - [Scrimba AI Courses](https://scrimbaguide.tech/docs/courses/ai/) - [Build a Support Agent with Vercel AI SDK](https://scrimbaguide.tech/docs/courses/ai/a-support-agent-with-vercel-ai-sdk/) --- # Learn to Code with AI Source: https://scrimbaguide.tech/docs/courses/ai/to-code-with-ai/ Guil Hernandez's free Learn to Code with AI runs about 4.5 hours across three modules. You paste ChatGPT prompts into the Scrimba editor, edit the code it returns, and ship about 15 small projects, from a drum kit to a Firebase-backed expense splitter. It works well for a first project this weekend; it will not teach you to program. Reviewed inside the course with a Pro account, September 2026: all 42 scrims opened, 40 transcripts read. This page is part of our [Scrimba AI courses](https://scrimbaguide.tech/docs/courses/ai/) catalog. This course is not part of any Scrimba career path. ## Quick answer It fits someone with an idea, no coding background, and a ChatGPT account open in a second tab. The catch: the recordings date from 2023, so the ChatGPT screenshots are stale even though the prompts still work. Finish it and want to understand the code you pasted? Move to [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/). **Learn to Code with AI** Build and deploy 15 small web projects by prompting ChatGPT for HTML, CSS, and JavaScript, then wiring four of them to a Firebase database. - Duration: 4.5 hrs - Level: Beginner - 3 modules - Taught by [Guil Hernandez](https://scrimba.com/@Guilh?via=u42d4986) [Start free on Scrimba](https://scrimba.com/learn-to-code-with-ai-c02m?via=u42d4986) ## Is it worth your time? Yes, for the person it is made for: someone with an idea, no coding background, and a ChatGPT account. The course costs nothing, and the format does something a YouTube video cannot. Guil pastes ChatGPT's code into the editor and it runs in the preview pane beside it, so when he changes `border-radius: 20px` to `0px` you see the button corners square off. Then he stops and hands you the editor for a challenge. There are 23 of those, and they are small enough that a beginner can finish them. The recordings date from 2023: the slides show the ChatGPT interface labelled "May 24 Version," the first project is a "Login with Twitter" button, and the Firebase code pins version 9.20.0 from Google's CDN. The prompts still work in today's ChatGPT, and the HTML, CSS, and JavaScript have not changed, but the screenshots will not match what you see on your screen. Guil promises in the module 1 wrap-up that "I'll be adding more sections to the course featuring new, more complex projects." As of September 2026 that has not happened. "Learn to code" means something specific here. You copy prompts from a `prompts.md` file, paste them into ChatGPT in another tab, and paste the answer back. The challenges are where you type real code, and they are mostly two or three line edits. Guil is upfront: "You are meant to punch above your weight in this course and work with code or take on challenges you don't fully understand." That is a fair deal for a prototyping course, but do not expect to write a project from a blank file when you finish. ## What you'll learn ### Course curriculum 3 modules · 40 lessons - Module 1: Build and deploy your first projects with ChatGPT (116 min, 16 lessons) - Module 2: Next-level projects with AI (107 min, 14 lessons) - Module 3: Build projects with Firebase (50 min, 10 lessons) Lesson counts are the scrims I counted in each expanded module in September 2026, 40 in total plus two short platform add-ons after module 3 (a Scrimba Docs intro and a certificate tip). Scrimba's module headers show 0/14, 0/8, and 0/1, which is the number of challenges in each module rather than the number of scrims, and the listing's structured data says 47 lessons, which counts something else again. When other pages on this site quote 47 lessons, that is Scrimba's number. ## Inside the course, module by module ### 1. Build and deploy your first projects with ChatGPT (116 min, 16 scrims) ![Title card for module 1 of Scrimba's Learn to Code with AI course: the words Learn to code with AI beside an illustrated figure in a polka-dot sweater](https://scrimbaguide.tech/img/scrimba/learn-to-code-with-ai/chapter-1-learn-to-code-with-ai-title-card.webp) *A login button, a hero section, a signup form, and a drum kit teach the paste-run-edit loop, ending in a Netlify deploy.* Three short scrims set the scene: a course welcome (the free preview), a two minute case for ChatGPT as "a stellar problem solver," and a sign-up walkthrough for OpenAI. Then "What you need to know about HTML and CSS" explains the two with a car analogy (HTML is the frame, CSS is the paint job) and shows the workflow you will repeat all course: copy a prompt from `prompts.md`, paste it into ChatGPT, paste the code back, click run. The projects start small and grow. "Build a login button" makes a Login with Twitter button, then challenges you to turn it into a GitHub button by editing one line of HTML and two of CSS. "Website hero section" builds a landing page for a fictional Hover Chair with a Google Font and a product image. "Subscription signup form" builds a BarkerBox dog-toy signup with three challenges: add a name field, add an image, then style it round with a border. Along the way Guil points out Flexbox and explains `alt` text properly. "What you need to know about JavaScript" is the first time you see a variable. From there the projects get interactive: an event invite called GIF Gala (two parts; part 1 has no transcript, part 2 covers `if`, `else if`, and swapping a background GIF based on the RSVP), then the "Cake raffle app," which is the first project built from a conversational prompt. Its reset button challenge is the hardest in the module, and Guil says so at 6:35: "This is likely the toughest challenge you've worked on so far." The solution includes a real bug: the list clears but the array does not, so old names keep winning. "Debug, get feedback, and improve your code" is the most useful scrim in the course. Guil gives you a broken ReelRewards promo-code page and fixes it with ChatGPT three times: a script tag in the wrong place, a form that refreshes the page, and a discount that applies to any code. The third one is your challenge. ![Learn to Code with AI, Debug lesson: a slide shows ChatGPT explaining a bug, above the code editor and a small preview pane.](https://scrimbaguide.tech/img/scrimba/learn-to-code-with-ai/debug-with-chatgpt-assignment-vs-equality-lesson.webp) *At 6:31 of the debugging challenge answer, ChatGPT spots that if (userCode = 'HALF') assigns instead of compares.* Screenshot of scrimba.com, taken by scrimbaguide.tech. The module ends with a "Drum kit app" (four challenges: name it, add a ride sound, add keyboard keys, then add snare, tom, and hi-hat yourself), a three minute Netlify drag-and-drop deploy, and a wrap-up. There is also a 1:41 scrim called "Dive deeper" that is a pitch for Scrimba's [Frontend Developer Career Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/). ### 2. Next-level projects with AI (107 min, 14 scrims) ![Title card for module 2 of Scrimba's Learn to Code with AI course: Next-level Projects with AI](https://scrimbaguide.tech/img/scrimba/learn-to-code-with-ai/chapter-2-next-level-projects-title-card.webp) *FaceBomp, a personal homepage, a smart home interface, and a Chrome extension move from one big prompt to many small ones.* The intro promises that "with AI at your side, you can quickly get off the ground with plain conversational English, and then gradually become more technical." The projects back that up. FaceBomp, a whack-a-mole game with your own photo as the mole, takes two scrims and 26 minutes. ChatGPT generates the grid, the timer, and the scoring. Your challenges are to shrink and hide the images with CSS `transform: scale(0)`, change the button text while a round is running, fix a doubled "Time left" label, and add a bump sound plus a different end sound for high scores. ![Learn to Code with AI, FaceBomp lesson: the whack-a-mole game runs in the preview pane next to the code editor.](https://scrimbaguide.tech/img/scrimba/learn-to-code-with-ai/facebomp-whac-a-mole-game-running-lesson.webp) *FaceBomp running at 12:05 of part 1. The doubled 'Time left' label is a real bug in ChatGPT's code; you fix it in part 2 by pointing the variable at the right element.* Screenshot of scrimba.com, taken by scrimbaguide.tech. "Project slideshow" asks for a dot-navigation image slider in one prompt and gets it, then adds autoplay with `setInterval`. "Personal homepage" is the biggest build: header, about, skills with progress bars, footer with Font Awesome icons, then a challenge to drop the slideshow into it. That homepage is what you push to GitHub in the next scrim (by dragging files into the browser, no git commands) and later connect to Netlify so every change deploys itself. The smart home interface, two scrims, is where Guil switches to many small prompts instead of one big one, and where you write your first prompt from scratch (for a glow effect on pressed buttons). "Turn your project into a mobile app" adds a `manifest.json` so the app installs on a phone home screen. Then SnapStash, a shopping wish-list Chrome extension in two scrims: a `manifest.json`, a popup, Chrome's storage API so the list survives a restart, delete buttons, and category grouping. You cannot test it inside Scrimba; you download the zip and load it at `chrome://extensions`. Guil's closing line sums up the module: "You didn't just build a Chrome extension. You created something that uses data persistence." The last scrim in the module is a two minute ad for Scrimba's affiliate program by co-founder Per Borgen, not course content. ### 3. Build projects with Firebase (50 min, 10 scrims) ![Title card for module 3 of Scrimba's Learn to Code with AI course: Build Projects with Firebase](https://scrimbaguide.tech/img/scrimba/learn-to-code-with-ai/chapter-3-build-projects-with-firebase-title-card.webp) *Four apps, a reconnected GIF Gala, Kudos Delight, LunchVote, and RoadWallet, save and sync data through Firebase's Realtime Database.* Module title cards from scrimba.com. Firebase is Google's hosted database. This module uses its Realtime Database, which pushes changes to every open copy of your app the moment they happen. Two short explainers and a setup scrim get you a project (you need a Google account) and show Scrimba's Firebase template, which hides your database URL behind an environment variable so you are not publishing it. "Add Firebase to a project" reconnects the GIF Gala invite from module 1 so guests' messages are saved and listed live. Then come three apps, each built from starter code plus one or two prompts. Kudos Delight is a compliment generator that stores kudos and shows a random one; both of its parts are challenges you complete with ChatGPT. LunchVote is a poll where colleagues add lunch spots and vote; part 2 adds a delete button and debugs a missing `set` import. RoadWallet splits trip expenses. ![Learn to Code with AI, RoadWallet lesson: the preview pane shows an expense form and a saved expense history list.](https://scrimbaguide.tech/img/scrimba/learn-to-code-with-ai/roadwallet-firebase-expense-history-lesson.webp) *This is what asking ChatGPT for the whole file, not a diff, gets you: RoadWallet's rewrite at 8:19 now saves expenses and travelers to Firebase.* Screenshot of scrimba.com, taken by scrimbaguide.tech. RoadWallet is the odd one out: most of the app is pre-written and the point, in Guil's words, "is to explore how ChatGPT can effectively interact with, modify, and enhance a substantial existing codebase." He asks for the complete file back rather than a diff, which is a habit worth copying. After the wrap-up there are two platform add-ons that are not by Guil: a 1:18 intro to Scrimba Docs by Tom Chant and a 0:56 "How to utilize your certificate" by Per Borgen again. ## What a lesson feels like Scrims run from one to fifteen minutes; the build scrims are mostly nine to fourteen. Each opens with the project files already in place (`index.html`, `styles.css`, `script.js`, and a `prompts.md` with the prompts Guil will use) and a slide for anything he needs to show outside the editor, such as ChatGPT's reply. He reads the prompt aloud, explains why it is written that way, then you watch the code land and the preview update. Challenges arrive as comments pasted into the file with a "pause me now." You edit, click run, and press play to see his solution. Only the first scrim carries a free-preview badge; the small icon next to a duration in the table of contents means "Challenge," and I counted 23 of them. Every scrim has captions, subtitles in ten languages, and a transcript panel under the settings menu, except two: "Interactive event invite - part 1" and "Lunch break poll" have no transcript at all. One thing to know before you start: ChatGPT is not inside Scrimba. You keep it open in another tab, and for the Chrome extension you also need to download the zip and load it in your own browser. Guil's tone is patient and repetitive on purpose; almost every scrim ends with "ask ChatGPT about any code you don't understand." ## Free or Pro: exactly what is gated Nothing in the course is gated. All 40 module scrims, all 23 challenges, and the three Firebase apps are free. There are no Solo Project (Pro) items, which is unusual for a Scrimba course. The only Pro item is the Certificate of Completion at the end of the table of contents. Scrimba's pricing page lists basic Discord access as free and the Pro-only channels as Pro, so the Discord server Guil points to in the intro is not a reason to upgrade. See [current plans](https://scrimba.com/our-pricing?via=u42d4986) if you want the certificate. ## How long it takes 4.5 hours is video runtime. Plan for 10 to 14 hours. Every build scrim has you pausing to paste a prompt into ChatGPT, read its answer, and paste code back, and the 23 challenges take a beginner five to fifteen minutes each. The account setup is real time too: OpenAI, Netlify, GitHub, Firebase, and Chrome's developer mode all get set up during the course. If you deploy every project and personalise the homepage as Guil asks, add another three to five hours. At an hour a day that is two to three weeks. ## Who it's for, and who should skip it It fits you if you have never coded, you want a working thing you can show someone, and you are comfortable working with ChatGPT in a second tab. It also fits designers, marketers, and founders who want to prototype without hiring anyone; the [pages for beginners](https://scrimbaguide.tech/docs/for/beginners/) cover that audience. Skip it if you already write HTML and JavaScript; the challenges will feel like busywork and the ChatGPT prompting is basic. Skip it if you want to understand how language models work or build with an API; that is [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/). And skip it if the age bothers you: the prompts still work, but it is ChatGPT only, with no mention of Claude, Cursor, Copilot, or any model newer than GPT-4. [Start Learn to Code with AI for free](https://scrimba.com/learn-to-code-with-ai-c02m?via=u42d4986) ## Prerequisites None in terms of code. You need a free OpenAI account for ChatGPT (any tier works; the course uses the free web app), a Google account for module 3, and free Netlify and GitHub accounts for the deploy scrims. The Chrome extension needs Chrome. Everything else runs in the Scrimba editor. ## Where it fits This is the gentlest entry on the [AI courses hub](https://scrimbaguide.tech/docs/courses/ai/), and it is not part of any Scrimba career path. The "Dive deeper" scrim that pitches the [Frontend Developer Path](https://scrimbaguide.tech/docs/paths/frontend-developer-path/) is right about the next step: if you finish and want to understand the code, go to [Learn HTML and CSS](https://scrimbaguide.tech/docs/courses/css/html-and-css/) and then [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/). If the Firebase module was the part you enjoyed, [Build a Mobile App with Firebase](https://scrimbaguide.tech/docs/courses/backend/a-mobile-app-with-firebase/) goes deeper on the same database. If you liked writing prompts, [Prompt Engineering for Web Developers](https://scrimbaguide.tech/docs/courses/ai/prompt-engineering-for-web-developers/) is the natural follow-on. ## Strengths and limits What it does well: it is free with nothing gated, the projects are things people want to build (a poll, an expense splitter, a browser extension), the debugging scrim teaches a real skill, and Guil explains each line ChatGPT produces instead of pasting and moving on. The Firebase module gets a beginner from no database to a working one in under an hour. Where it is limited: the recordings are from 2023 and the ChatGPT screenshots are out of date, two scrims have no transcript, the challenges are small edits rather than full builds, ChatGPT lives outside the editor so there is a lot of tab switching, and the promised extra modules never arrived. It teaches you to steer an AI through a project, not to program. ## Related courses and comparisons - [Intro to AI Engineering](https://scrimbaguide.tech/docs/courses/ai/ai-engineering/), the next step if you want to call an AI model from code - [Prompt Engineering for Web Developers](https://scrimbaguide.tech/docs/courses/ai/prompt-engineering-for-web-developers/), for better prompts than the ones here - [Build a Mobile App with Firebase](https://scrimbaguide.tech/docs/courses/backend/a-mobile-app-with-firebase/), a deeper Firebase project - [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/), to learn what the generated code means - [Intro to Mistral AI](https://scrimbaguide.tech/docs/courses/ai/mistral-ai/), another free AI starting point - [Courses for beginners](https://scrimbaguide.tech/docs/for/beginners/), where this one fits **Q: Is Learn to Code with AI free on Scrimba?** Yes. All 40 module scrims, all 23 challenges, and the Firebase projects are free with no card required. There are no Pro solo projects in this course. Pro only adds the certificate. **Q: Do I need to know how to code first?** No. The course starts with what HTML and CSS are and introduces variables in scrim 8. You copy prompts into ChatGPT and edit the code it returns; the challenges are one to three line changes. **Q: Who teaches it?** Guil Hernandez, a Scrimba teacher, for all 40 module scrims. Two short add-ons at the end are by Tom Chant (Scrimba Docs) and Per Borgen (using your certificate). **Q: What do you build?** About 15 mini projects: login buttons, a hero section, a signup form, the GIF Gala RSVP page, a cake raffle, a drum kit, the FaceBomp whack-a-mole game, a project slideshow, a personal homepage, the Home Harmony smart home interface (installable as a mobile app), the SnapStash Chrome extension, and four Firebase apps: GIF Gala with saved messages, Kudos Delight, LunchVote, and RoadWallet. **Q: Is the course out of date?** Partly. The recordings date from 2023: the slides show the May 2023 ChatGPT interface and the Firebase code pins version 9.20.0. The prompts still work in current ChatGPT and the HTML, CSS, and JavaScript are unchanged, but the screenshots will not match your screen. **Q: Do I need a paid ChatGPT plan?** No. Guil uses the free ChatGPT web app. He mentions GPT-4 once, in the RoadWallet scrim, but every prompt works on the free tier. **Q: Do I need to install anything?** Not for the first two modules; everything runs in the Scrimba editor with ChatGPT in another tab. You download a zip to deploy to Netlify, to upload to GitHub, and to load the Chrome extension. Module 3 needs a Google account for Firebase. **Q: How long does it take?** About 4.5 hours of video, but plan for 10 to 14 hours once you count the ChatGPT round trips, 23 challenges, and account setups, or two to three weeks at an hour a day. **Q: Does it have transcripts?** Yes for 40 of the 42 scrims, with captions and subtitles in ten languages. Interactive event invite part 1 and Lunch break poll have no transcript. **Q: Will this teach me to program properly?** Not on its own. It teaches you to get a project built by prompting and editing. To learn the underlying code, follow it with Learn HTML and CSS and Learn JavaScript. ### Related Guides - [AI Engineer Path](https://scrimbaguide.tech/docs/paths/ai-engineer-path/) - [Scrimba AI Courses](https://scrimbaguide.tech/docs/courses/ai/) - [Build a Support Agent with Vercel AI SDK](https://scrimbaguide.tech/docs/courses/ai/a-support-agent-with-vercel-ai-sdk/) --- # Scrimba Backend Courses Source: https://scrimbaguide.tech/docs/courses/backend/ Scrimba's backend catalog is four courses, from a 46-minute regex crash course to the 4.8-hour Supabase build, and every one of them runs on JavaScript and TypeScript. That means a frontend developer can add databases, auth, and persistence without switching languages. Start with the free [Learn SQL](https://scrimbaguide.tech/docs/courses/backend/sql/). ## Where to start Database literacy is what separates copy-paste developers from people who can debug a slow query, and it pays off whether you later use raw SQL, Supabase, or Firebase. [Learn SQL](https://scrimbaguide.tech/docs/courses/backend/sql/) (3.8 hrs) is free, runs Postgres in the browser, and is the strongest first step into this hub. Considering the full Backend path instead? Read our [hands-on review of it](https://scrimbaguide.tech/blog/scrimba-backend-path-review/). [Start Learn SQL for free](https://scrimba.com/learn-sql-c0aviq0aha?via=u42d4986) ## All backend courses | Course | Level | Access | Length | | --- | --- | --- | --- | | [Learn SQL](https://scrimbaguide.tech/docs/courses/backend/sql/) | Beginner | Free | 3.8 hrs | | [Learn Regular Expressions](https://scrimbaguide.tech/docs/courses/backend/regular-expressions/) | Intermediate | Free | 46 min | | [Intro to Supabase](https://scrimbaguide.tech/docs/courses/backend/supabase/) | Intermediate | Free | 4.8 hrs | | [Build a Mobile App with Firebase](https://scrimbaguide.tech/docs/courses/backend/a-mobile-app-with-firebase/) | Intermediate | Pro | 2.0 hrs | ## Inside the courses ![Opening slide of Learn SQL on Scrimba, purple gradient, naming Gregor Thomson as the teacher](https://scrimbaguide.tech/img/scrimba/learn-sql/chapter-1-intro-to-sql-title-card.webp) *Learn SQL: free, and the natural place to start this hub.* ![Opening slide of Learn Regular Expressions on Scrimba, white monospace text on freeCodeCamp green](https://scrimbaguide.tech/img/scrimba/learn-regular-expressions/regular-expressions-title-card.webp) *freeCodeCamp's own curriculum runs here as 36 short scrims, nothing gated: Learn Regular Expressions.* ![Opening slide of Intro to Supabase on Scrimba, a lightning bolt over the course name and Jonathan Hill's credit](https://scrimbaguide.tech/img/scrimba/intro-to-supabase/chapter-1-intro-to-supabase-title-card.webp) *Intro to Supabase: free end to end, but you build inside your own Supabase project.* ![Opening slide of Build a Mobile App with Firebase on Scrimba, with Rafid Hoda's name beside an illustrated instructor](https://scrimbaguide.tech/img/scrimba/build-a-mobile-app-with-firebase/course-intro-title-card.webp) *Two sample scrims, then Pro: Build a Mobile App with Firebase.* Chapter title cards from scrimba.com. - [Learn SQL](https://scrimbaguide.tech/docs/courses/backend/sql/) runs Postgres in the browser (PGlite) and packs 62 challenges into 49 scrims. - [Learn Regular Expressions](https://scrimbaguide.tech/docs/courses/backend/regular-expressions/) is freeCodeCamp's curriculum as 36 short scrims, nothing gated. - [Intro to Supabase](https://scrimbaguide.tech/docs/courses/backend/supabase/) is free end to end, but you build in your own Supabase project. - [Build a Mobile App with Firebase](https://scrimbaguide.tech/docs/courses/backend/a-mobile-app-with-firebase/) is Pro after two sample scrims; the free [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) course ends with the same Firebase build. ## How to progress Run [Learn SQL](https://scrimbaguide.tech/docs/courses/backend/sql/) for database fundamentals, then [Intro to Supabase](https://scrimbaguide.tech/docs/courses/backend/supabase/) for SQL plus auth, storage, and row-level security in one platform. [Build a Mobile App with Firebase](https://scrimbaguide.tech/docs/courses/backend/a-mobile-app-with-firebase/) covers Google's backend-as-a-service if you want easy mobile sync instead. ## More backend on the JavaScript track Scrimba files its server-side runtimes under JavaScript. For the request-response side of backend work, follow this hub with [Learn Node.js](https://scrimbaguide.tech/docs/courses/javascript/nodejs/), [Learn Express.js](https://scrimbaguide.tech/docs/courses/javascript/expressjs/), and [Intro to NestJS](https://scrimbaguide.tech/docs/courses/javascript/nestjs/) on the [JavaScript hub](https://scrimbaguide.tech/docs/courses/javascript/). ## Where it fits The fastest structured route is the [Backend Developer Path](https://scrimbaguide.tech/docs/paths/backend-developer-path/), which sequences Node, Express, SQL, TypeScript, and deployment into one progression. The broader [Fullstack Developer Path](https://scrimbaguide.tech/docs/paths/fullstack-developer-path/) adds the frontend half. Browse every track on the [Learning Paths hub](https://scrimbaguide.tech/docs/paths/). ## Related - [TypeScript course](https://scrimbaguide.tech/docs/courses/typescript/), [JavaScript courses](https://scrimbaguide.tech/docs/courses/javascript/), and [all courses](https://scrimbaguide.tech/docs/courses/) - [Practice API calls](https://scrimbaguide.tech/docs/practice/practice-api-calls/) - [Scrimba pricing](https://scrimbaguide.tech/docs/pricing/) and [Pro vs Free](https://scrimbaguide.tech/docs/pricing/pro-vs-free/) ## Ship a real backend in JavaScript SQL and Supabase are free to start, no Pro account needed. [Try Scrimba free](https://scrimba.com/?via=u42d4986) ### Related Guides - [Learning Paths](https://scrimbaguide.tech/docs/paths/) - [Is Scrimba Free? Pro vs Free](https://scrimbaguide.tech/docs/pricing/pro-vs-free/) - [Best Free Courses](https://scrimbaguide.tech/blog/best-free-scrimba-courses/) --- # Build a Mobile App with Firebase Source: https://scrimbaguide.tech/docs/courses/backend/a-mobile-app-with-firebase/ Rafid Hoda's Build a Mobile App with Firebase is a two-hour Pro project course. You build a shopping list app in plain HTML, CSS and JavaScript, store its items in a Firebase Realtime Database, and finish by installing it on your phone's home screen. It's a tight, well-sequenced two hours if you already write basic JavaScript. Reviewed inside the course with a Pro account, September 2026: all 38 scrims and transcripts. ## Quick answer Build a Mobile App with Firebase suits anyone who has finished a beginner JavaScript course and wants to watch data leave the browser for the first time, the shortest route to that moment in the Scrimba catalog. The catch: everything past the first two scrims sits behind Pro. The same Firebase workflow closes the free [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) course, applied to a different app, so if you've already built that course's leads tracker, you've seen most of the Firebase side of this one already. **Build a Mobile App with Firebase** A guided build of a realtime shopping list with vanilla JavaScript and the Firebase Realtime Database, finished as a progressive web app on your phone. - Duration: 2.0 hrs - Level: Intermediate - 38 lessons - Taught by [Rafid Hoda](https://scrimba.com/@rafidhoda?via=u42d4986) [View on Scrimba](https://scrimba.com/build-a-mobile-app-with-firebase-c0g?via=u42d4986) ## Is it worth your time? The course does one thing and does it in the right order. Every concept shows up because the shopping list needs it: you need `push` to save an item, `onValue` to see it again after a refresh, `Object.values` to loop over what comes back, a unique ID before you can delete anything, and `createElement` because `innerHTML` strings cannot carry a click handler. Nothing is taught ahead of when you use it, which makes the two hours feel short. The teaching style is challenge-first. In most scrims Rafid writes the task as a comment, says "pause here, try it out for yourself and I'll be right back," and then solves it on screen. I counted challenges in 20 of the 38 scrims, plus the solo project, and some scrims have three in a row. You cannot get through this course by watching. Two things to know before you pay. First, the material dates from early 2023: the Firebase library (the SDK) is pinned to version 9.15.0 and a console timestamp in one lesson reads 2023-01-31. The functions still work in 2026, but the Firebase console screenshots in the slides will not match what you see. Second, the same Firebase workflow closes Scrimba's free [Learn JavaScript](https://scrimbaguide.tech/docs/courses/javascript/learn-javascript/) course, applied to a different app: its final module takes the leads tracker Chrome extension and swaps localStorage for a Realtime Database, with the same push, `onValue`, `remove`, viewport, favicon, manifest and Netlify steps. This standalone version builds a shopping list instead, adds click-to-delete with `Object.entries` and `createElement`, more asides (flexbox, `user-select`) and a solo project, but if you have already done that module, you have seen most of the Firebase side of this. ## What you'll learn Scrimba lists the 38 scrims flat, with no module headings. The groupings below are mine, so you can see where the time goes; durations are the sum of the scrim timers in each group. ### Course curriculum 8 modules · 38 lessons - Module 1: Getting set up (12 min, 3 lessons) - Module 2: Connecting Firebase (17 min, 3 lessons) - Module 3: Reading data in realtime (31 min, 7 lessons) - Module 4: Styling the list (7 min, 3 lessons) - Module 5: Deleting items (23 min, 5 lessons) - Module 6: Making it feel like a mobile app (15 min, 9 lessons) - Module 7: Deploy, install, share (11 min, 5 lessons) - Module 8: Solo project and wrap-up (7 min, 3 lessons) I counted 38 scrims on the course page in September 2026, adding up to 2 hours 3 minutes of video; Scrimba's listing and its structured data say 39 lessons, which I take to include the certificate entry that is not a scrim. ## Inside the course, module by module ### 1. Getting set up (12 min, 3 scrims) ![Title slide of Scrimba's Build a Mobile App with Firebase course, reading Mobile App with Firebase, with Rafid Hoda, next to an illustrated instructor](https://scrimbaguide.tech/img/scrimba/build-a-mobile-app-with-firebase/course-intro-title-card.webp) *This module sets expectations, then has you log an input's value and copy a finished CSS design for the Add to Cart shell.* Title card from scrimba.com. The intro scrim is the pitch: you are cooking, you are out of an ingredient, you cannot remember what else you needed. The app is called Add to Cart. Rafid is upfront in the first two minutes that "what we'll be building is not technically a native mobile app. It's a web app that's disguised as a mobile app," and he tells you to go do the free HTML and CSS and JavaScript courses first if you cannot build a form on your own. Scrim 2 hands you an input and a button and asks you to log the input's value on click, which is the level the course starts at. Scrim 3 is a CSS challenge with a finished design to copy: a 320px column, a cat image, a rounded input and a red button. Both of these scrims are free previews. ### 2. Connecting Firebase (17 min, 3 scrims) Scrim 4 is the ten-minute aside where the database arrives, and it is the most important scrim in the course. Rafid walks through the Firebase console: create a project, skip Analytics, create a Realtime Database, pick a region, start in test mode, copy the database URL. Then he explains ES module `import` and `export` from scratch with a tiny `add` function, because that is how the Firebase SDK is loaded. The `Cannot use import statement outside of module` error is shown on purpose so you learn to add `type="module"` to the script tag. Then `initializeApp`, `getDatabase`, `ref` and `push` go in one by one and three movie titles land in the database. He is strict about one thing, and repeats it in scrim 5: "you need to make sure that this is replaced with your specific database URL. Otherwise you will be writing to my database." Scrim 5 makes you redo the whole setup for the shopping list as a challenge. Scrim 6 covers security rules in two and a half minutes: test mode expires after 30 days, so you set read and write to `true`, and Rafid admits that "literally anyone can write to your database" and moves on. ### 3. Reading data in realtime (31 min, 7 scrims) The next half hour is where the app becomes an app. Scrim 7 appends items to a `

`, set its `textContent`, `append` it to the `