Turning learning into a feedback loop: how seven principles connect into one method

Seven principles, one learning loop

The original post walks through these principles in order: learn by doing, shorten the feedback loop, struggle before you search, learn just in time, retrieve instead of recognize, connect before you collect, and recognize that learning compounds. Read as separate items, they sound like seven slogans. But trace them through a real task, and you’ll see they link end to end.

Start by picking a task slightly beyond your current ability. Working on it exposes gaps. Don’t search immediately—form your own judgment first. Then add just a little knowledge to fill the specific gap, return to the task, and redo it. Get feedback from the outcome, from users, from a teacher, or from a test. Finally, close your materials and recap what you learned, connecting it to what you already know. When the next task begins, you have more patterns to draw on.

To check whether the loop is actually turning, ask two questions: What can I do with what I already know? And how quickly can I find out I’m wrong? The first pushes learning into action; the second determines how fast you correct course.

This also explains why “watch one more course” so often fails to produce progress. A course adds input, but it doesn’t automatically trigger trying, feedback, retrieval, or connection. If the loop isn’t turning, your time just accumulates on the consumption side.

Do first: let the problem set the learning order

Hades lists Learn by Doing and Learn Just in Time as separate principles, but in practice they’re tightly linked.

Someone who wants to build a product often makes a grand pre-study list: programming, design, marketing, sales—all of it before starting. Six months later, they know a bit of everything and still have no product. Do the opposite: build a minimal version first, and the learning order becomes concrete fast. The page won’t load? Learn deployment. Users are confused? Work on the copy. Nobody will pay? Validate the need and the price.

Writing works the same way. Reading ten books on writing won’t tell you in advance whether your own article will trip over the topic, the structure, the argument, or the sentences. Your first real piece will expose each of those problems. Sales is no different: you can memorize frameworks and still freeze when the customer says “that’s too expensive.” A real conversation gives you the next drill—how to probe budget, value, and alternatives.

“Doing” here needs to meet two conditions. First, the task must produce an observable result. Second, the difficulty should be only slightly above your current level. If the task is too easy, no new gaps surface. If the jump is too big, you’ll hit dozens of problems at once and won’t know which to fix first.

A meta-analysis covering 225 undergraduate STEM studies on active learning found that exam and concept-test scores improved by an average of 0.47 standard deviations under active learning. That result supports the direction of active participation, but the studies are limited to undergraduate STEM classrooms—you can’t translate it into “any skill can be learned 47% faster.”

Then search: keep your own judgment first

The third principle is Struggle Before You Search. In the AI era, it’s especially easy to misunderstand.

When your code throws an error, you can paste the whole thing into an AI, copy the fix, and the problem vanishes in under a minute. But the next time a similar error appears, you still won’t know what the message was pointing at, which change you made, or which assumption got ruled out. Task completion gets faster, but your diagnostic ability doesn’t grow with it.

Struggling first leaves behind a trace of thinking you can compare against. Read the error message, guess a cause, change one variable, and observe the result. Then look at what the AI or a search returns, and you can compare: what was my original judgment, what evidence did the answer add, and where did my reasoning go off track? That’s how an external answer enters your own mental model—instead of being just one more paste operation.

Two randomized studies on ninth-grade math by Manu Kapur offer a bounded example of this sequence. Students who tried solving new problems first and then received instruction outperformed the teach-then-practice group on conceptual understanding and transfer to new problems. Both groups scored well on procedural knowledge. This approach is called productive failure. The failure in the study was designed, and instruction followed immediately. It’s not an endorsement of getting stuck indefinitely.

A practical approach is to set a struggle window: spend 5–10 minutes on a low-stakes problem on your own, and write down at least one hypothesis and one test. When you hit the time limit, run into a safety risk, or your experiments stop producing new information, get help. Struggling first creates the learning material; getting help promptly completes the correction.

Feedback for correction, retrieval for verification

Shorten the Feedback Loop is about correction. The original post gives the example of two writers: the first finishes ten pieces in a month and publishes them all at once. The second publishes after each piece, watches where readers drop off and which ideas get shared, and then writes the next one. Both writers complete ten pieces, but the second gets ten rounds of external correction.

Equal practice time doesn’t mean equal feedback loops. Repeat an action 100 times without knowing what’s wrong, and you can get very good at doing it wrong.

Still, “faster feedback is always better” isn’t an unconditional rule. A meta-analysis covering 435 studies, 994 effects, and over 61,000 learners on feedback found an average effect of d = 0.48—but the results varied widely, and the information contained in the feedback mattered a lot. Saying “you did poorly” gives almost no guidance for the next attempt. Effective feedback should help answer three things: what was the goal, where did the current result deviate, and what should change next. Some tasks may also work better with immediate feedback, others with delayed.

Retrieval Beats Recognition handles a different job: verifying whether knowledge can be called up when the material is gone.

When you reread, the sentences on the page feed you cues, and your brain produces a familiar “I know this” feeling. Close the book, write down three key points in your own words, and the cues disappear—only then do the gaps show up. Watching a lecture video and immediately paraphrasing it without notes, or solving a new example with a concept you just learned, does the same thing: it forces your brain to rebuild rather than recognize.

A systematic review of retrieval practice in real classrooms screened nearly 2,000 abstracts and included 50 experiments with a total sample of 5,374. Of the 49 effects that could be computed, 28 showed moderate or large gains. The researchers also noted major differences across studies in subject matter, test format, feedback, and implementation. Retrieval practice works, but the exact approach still needs to be adapted to the task.

Feedback and retrieval aren’t substitutes. Feedback points out deviation from the outside; retrieval checks from the inside whether you can regenerate the knowledge. A full practice session should ideally have both: get corrective information when you’re done, then close the material and recap or redo it after some time passes.

Connect to old knowledge, and compounding can happen

The last two principles are Connect Before You Collect and Learning Compounds.

An isolated fact can only answer the question it was originally tied to. Once you build connections, a concept gets more entry points. Someone who has studied psychology will notice motivation, attention, and social proof when they next look at marketing. Someone who has studied marketing and then moves into sales will understand why the same pitch lands differently on different people. And writing training forces those vague recognitions into structures you can actually explain.

That’s also part of why experienced people pick up new things faster. When they see a new business model, they align it with familiar acquisition channels, cost structures, failure cases, and user behaviors. New information doesn’t have to be organized from scratch; existing patterns give it a place to land.

“Learning compounds” is therefore a conditional metaphor. The sheer volume of things you’ve saved doesn’t compound. Knowledge only lowers the cost of the next understanding after it’s been retrieved, applied, and connected. And connections can go wrong: old experience can make you apply a familiar framework too early and miss what’s different about the new problem. Every connection should come with one follow-up question—where is this situation the same as the old case, and where is it different?

Run one loop today: the 30-minute practice method

This method doesn’t ask you to rework your entire learning system. Pick one real problem today and run one loop in 30 minutes.

1. 3 minutes: define the output. Write down the observable result you want by the end of the loop, such as “get the form to submit one row of data” or “write an opening a reader can retell.”
2. 10 minutes: try on your own. Don’t look up answers. Record at least one hypothesis, one action, and the result.
3. 7 minutes: fill in the gap. Search only for the specific gap that surfaced. If you’re using AI, give it your own judgment first, then ask it to point out what’s wrong, what evidence it’s using, and what to check next time.
4. 7 minutes: redo the task. Turn the new information into a new action and see whether the result changes.
5. 3 minutes: recap without looking. Write down, from memory: what was the problem, where was I wrong, what evidence changed my judgment, and what should I check first next time.

The completion criteria are straightforward: you get an observable result, some feedback that can guide the next attempt, and an explanation you can retell without the source material. Failing to finish the task doesn’t mean the loop was worthless. As long as the gap is clearer than when you started, the next round has a precise point of entry.

Hades’ seven principles ultimately point to the same thing: move information into action quickly, let action produce feedback, and turn that feedback into reusable knowledge through retrieval and connection. Learning speed is determined by both the quality of the loop and how many times you run it.