# Finished the Tutorial. Still Can't Build?

**Summary:** Watching tutorials, following along, and building your own project practice different decisions. A reading-list example shows how feedback turns mistakes into useful learning.

- Canonical: https://markhuang.ai/blog/finished-the-tutorial-still-cant-build
- Language: en
- Author: [Mark Huang](https://markhuang.ai/about)
- Published: 2026-11-16
- Section: Behavior & Mindset
- Tags: learning, tutorials, self-learning, project-based-learning, mindset
- License: https://creativecommons.org/licenses/by-nc/4.0/

---

![An illustrated tutorial example beside a reading-list project being revised to meet a new requirement](https://cdn.markhuang.ai/blog/finished-the-tutorial-still-cant-build/hero.webp)

*Illustration: a working example gives you a starting point. Changing a requirement gives you decisions to make.*

You finish a tutorial, and the app works. Then you try to add a feature the instructor never covered, and you do not know where to start.

When I learn a new tool, I want to find out which parts I can use without the demonstration. Watching someone explain a method, following their instructions, and using what you have learned to build something you want give you different kinds of practice. A finished tutorial project does not tell you which decisions you can make independently yet.

I believe making mistakes and investigating them can help close that gap. A [2017 review by Janet Metcalfe](https://www.annualreviews.org/content/journals/10.1146/annurev-psych-010416-044022) describes how mistakes followed by corrective feedback can benefit learning. A failed attempt gives you something specific to question. The useful part is finding out what happened, correcting your understanding, and checking the next attempt.

## Three ways to work with the same tutorial

Imagine learning a new tool because you want a small app that tracks books you have read. The following example is hypothetical. It compares the decisions involved in three approaches, rather than the results of an experiment.

### Read or watch to understand the idea

You watch someone build a reading list. They explain how an input becomes an entry on the screen and how the list changes when a reader clicks a button. You begin to recognize the parts and learn the words used to describe them.

This can be a useful first pass. Before investing time in a tool, you might want to know what it does or whether it fits your project. A clear explanation can also make unfamiliar documentation easier to approach.

But watching does not require you to make the instructor's decisions. They have already chosen what to build, which parts to introduce, and how to recover from problems. Their explanation can feel clear while your ability to apply it remains untested.

### Follow along to practice the method

Now you build the example alongside the instructor. You set up the project, enter the code, and check whether your list behaves like theirs. You get practice with the actual environment, including the small details that were easy to miss while watching.

There is real work here. An installation can differ from the demonstration. A typo can change the result. You may need to pause and trace how information moves through the app.

Following along still leaves many decisions with the author. If you only check that your screen matches the video, it is easy to finish without knowing why a particular step was necessary. Try predicting the result of a small change before making it. Explaining why the prediction was right or wrong asks more of you than matching the screen.

### Build for a requirement you chose

Suppose your own reading list needs to keep its entries after a page refresh. The tutorial example only keeps them while the page is open.

You add a book, reload, and the list is empty. The app can display an entry, but it does not yet meet your requirement. You have a question to investigate: where was that entry stored, and what happens to that location when the page loads again?

For a simple exercise on one browser, [browser local storage can retain data across sessions](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage). You still need to work out when to save the list and how to read it back. If you later want the same list on another device, that introduces a different requirement.

Your project gives the reference material a purpose. You can look for the part that answers your question, try it, and test whether the book is still there after a refresh.

These approaches can overlap within the same afternoon. You might watch an explanation, follow a worked example, and then extend it. They are ways to practice, not fixed categories of learner. Someone who follows a tutorial thoughtfully can investigate deeply; someone building an original project can still copy solutions without understanding them.

## What the mistake helps you notice

In the reading-list example, the missing entry exposes an assumption: seeing data on a screen does not mean it has been saved somewhere that survives a reload.

Once you notice that distinction, you can ask better questions. What survives? What gets recreated? Which part of the app should be responsible for saving? A storage feature that once looked like another instruction now answers a problem you understand.

I want practice to give me that kind of question. An instruction may be correct before I understand why anyone needed it. Trying something gives me a result to compare with the explanation. It can also reveal the limits of a tool or a method that worked in a smaller example.

I touched on this in [AI Makes Building Easier. I Still Have to Learn.](/blog/ai-makes-building-easier) Here, the practical question is how to move from someone else's demonstrated path to decisions I can make for my own project.

There is a limit to the argument. Repeating the same failed attempt without inspecting it may leave you just as confused. If you cannot yet identify the relevant parts, a worked example or an explanation from someone more experienced may be the most useful next step.

Janet Metcalfe's review, [Learning from Errors](https://www.annualreviews.org/content/journals/10.1146/annurev-psych-010416-044022), describes evidence that making errors followed by corrective feedback can benefit learning. The correction, including attention to the reasoning behind the error, matters. That supports making room for mistakes during practice; it does not support treating every failure as progress.

Research on [problem solving followed by instruction](https://journals.sagepub.com/doi/full/10.3102/00346543211019105) also offers useful context. Tanmay Sinha and Manu Kapur combined results from multiple studies and found an overall benefit for that sequence, while some learner groups and learning goals favored instruction first. Productive failure, a particular design within this research, includes a later phase that connects attempted solutions to the concepts being taught.

Those educational studies do not establish that every independent software project makes everyone learn faster. I take a more bounded lesson from them: let a manageable attempt produce questions, then use feedback and instruction to work through those questions. Keep the practice small enough that a mistake is recoverable.

## The tutorial may depend on an older world

A mismatch can also come from the instructions. The video may use a different version, an earlier interface, or a setup the tool's maintainers no longer recommend.

For example, React [deprecated Create React App for new apps on February 14, 2025](https://react.dev/blog/2025/02/14/sunsetting-create-react-app). An older tutorial might still begin with that setup. React's announcement also said Create React App would continue in maintenance mode, so deprecation does not mean every existing tutorial project suddenly stopped working.

The distinction is useful: an older lesson can still explain a sound concept while its setup advice needs updating. Check the versions and the current official documentation before deciding that the whole lesson is wrong or that you failed to follow it correctly.

Building for your own requirement gives you a reason to make that check. Does the recommended method still fit? What has changed? Does a newer approach solve your problem better, or does it add complexity you do not need? The answer might confirm the tutorial's approach. It might lead you elsewhere.

I want to learn enough to make that judgment, rather than attach my understanding to one recorded sequence of steps.

## Change one thing the instructor did not choose

You do not need a large original project to start. A useful next exercise can fit inside a tutorial you already finished:

1. Choose one small requirement, such as keeping reading-list entries after a refresh.
2. Write down what you expect to happen and which part you think needs to change.
3. Try it. Use the result, the documentation, or someone else's feedback to investigate any mismatch.
4. Test again, then explain what changed and why it worked.

Use the tutorial again when it helps. Look up syntax you forgot. Ask for an explanation when you cannot connect the pieces. You are practicing how to reach and check an answer, so access to references is part of the work.

The result I would care about is being able to explain where the reading-list entries go and demonstrate that they survive a refresh. That is a more useful sign of understanding than having another completed video in my history.
