Learning Any New Skill Starts with Building a Feedback Loop

Learning new skills has always been a kind of hobby for me. I get energy from that moment when something finally clicks. A topic that used to feel complicated suddenly becomes clear. A confusing process starts to have shape. You move from “I have no idea what is going on” to “I think I can do this again.”

For a long time, I assumed this feeling was quite natural for everyone. But over time, I realised it is not always the case. For many people, learning something outside their normal routine feels difficult, slow, or even impossible. Not because they are not capable, but because they don’t have a structure for learning.

And this matters even more today, because information is everywhere. You can watch ten tutorials in one night. You can ask AI to explain a topic in five different ways. You can download high-quality resources instantly. But access to information does not mean you have learned anything.

In fact, sometimes too much information makes learning harder. It gives you the feeling that you are making progress, while you are only collecting more fragments.

So in this issue, I want to make the previous story more concrete. Instead of focusing on DEM rendering itself, I want to extract the learning pattern behind it.

The pattern has five stages: follow, reproduce, experiment, isolate, and modify.

These labels are not the most important part. The important part is that together, they create a feedback loop. When you are learning something new, the biggest risk is drifting. You consume content, try a few random things, watch more tutorials, and feel busy. But you don’t really know whether you are improving.

A good learning structure gives you a small end-to-end slice. Something that works from start to finish. Once you have that slice, you know what “working” looks like. You can compare your own attempts against it. You can see where you are stuck. You can adjust deliberately.

That is where real learning starts.

The first step is simple: find one good tutorial and follow it as closely as possible.

This sounds obvious, but I think it is easy to underestimate. When we learn something new, especially if we already have experience in another field, we often want to improve the process too early. We want to skip steps, use better tools, optimise the workflow, or add our own creative twist.

But in the beginning, that usually makes learning harder.

At this stage, the goal is not deep understanding. The goal is to build a complete working slice from start to finish. You want to see the whole path once, even if you don’t fully understand every detail yet.

In my DEM rendering experiment, this meant importing the DEM data into QGIS first, inspecting the elevation values, and getting a rough sense of what kind of data I was working with. Then I brought that data into Blender, applied displacement to a mesh, adjusted the material and lighting, and finally rendered the terrain.

By the end of this stage, I was not an expert. There were still many things I didn’t understand. But I had something much more useful than a pile of disconnected notes.

I had a result.

I knew what “done” looked like.

That became my reference point. Without this, I would only be collecting fragments of knowledge: a little bit of GIS, a little bit of Blender, a little bit of rendering, a little bit of terrain data. But with a complete slice, I had a feedback baseline.

And that baseline is very important. It gives you something to compare against. It turns learning from vague exploration into a visible process.

After completing the tutorial once, the next step is to recreate a similar result without following the tutorial step by step.

This is where learning becomes more active.

When you follow a tutorial, many things feel familiar. You may think, “Yes, this makes sense.” But recognition is not the same as control. You can recognise a workflow while still being unable to reproduce it.

So the real test is whether you can rebuild the process yourself.

For my terrain rendering experiment, I chose a different dataset and tried to go through the workflow again. This time, I did not follow the tutorial line by line. I had to remember the main steps, make decisions, adjust parameters, and recover when the output looked wrong.

That forced me to think through the workflow instead of just copying instructions.

This step transforms passive recognition into active recall. And recall is where a lot of real learning begins. You start to notice which parts are stable in your mind and which parts are still blurry.

Can you remember the main sequence? Can you explain why each step exists? Can you fix the result when it does not look right? Can you complete the workflow without constantly going back to the tutorial?

If the answer is no, that is not a failure. That is useful feedback.

Each time you rebuild the workflow, you discover where you hesitate, where you forget, and which part needs more attention. That is much better than immediately watching another tutorial and adding more information on top of an unstable foundation.

Once you can rebuild the workflow on your own, you can start experimenting.

But the key is to experiment deliberately.

When something is still new, it is tempting to change many things at once. You try a new dataset, a new setting, a different tool, a different output style, and maybe a few random suggestions from the internet. Sometimes it works, but when it doesn’t, you have no idea what caused the problem.

A better approach is to change one variable at a time.

In my case, I adjusted the displacement scale and observed how the terrain became more exaggerated or more flattened. Then I changed the lighting angle to see how shadows revealed different terrain features. Later, I changed materials and rendering settings to see how they affected the final image.

Each change was small, but intentional.

Because I already had a working baseline, I could clearly see the effect of each modification. I was no longer guessing randomly. I was probing the system and watching how it responded.

This is very similar to refactoring code. If you change ten things at once and something breaks, debugging becomes much harder. But if you change one thing at a time, the feedback is clearer.

The same principle applies to learning. Small, controlled experiments help you understand cause and effect.

And once you understand cause and effect, the skill becomes less mysterious.

At some point, you will hit friction.

This is usually the moment when many people go back to broad learning. They search for another course, another book, another long explanation, or another “complete guide.” Sometimes that helps, but often the problem is much smaller.

You don’t need to understand everything. You need to understand the specific part that is blocking you.

For me, the confusing part was how grayscale values represent elevation, and how Blender interprets those values as displacement. I could use the workflow, but this part still felt blurry. I didn’t fully understand why a certain image created a certain shape.

So instead of reading broad theory about DEM data, I isolated that single concept. I created a simple grayscale image myself and applied it as displacement on a basic mesh.

Suddenly, the concept became visible.

The lighter area pushed the mesh higher. The darker area stayed lower. The abstract idea became something I could see and control.

This is why isolation works so well. You are not learning in the abstract. You are fixing a specific weakness inside a structure that already exists.

Because you already have the end-to-end slice, you know where this concept fits. So when you isolate and understand it, you can plug that knowledge back into the whole process.

That makes the learning stick.

After repeating the workflow several times, experimenting with variations, and isolating confusing parts, you can start modifying the process itself.

This is usually the moment when the skill starts to become yours.

You replace some steps with better alternatives. You remove parts that are unnecessary. You automate small pieces. You develop your own preferences. You begin to understand not only what to do, but also why the process works.

At that point, you are no longer just following instructions.

You are designing your own workflow.

And I think this is one of the clearest signs that you have truly learned something. Not because you consumed enough content. Not because you finished a course. Not because you collected enough resources.

But because you can control the process, explain the trade-offs, and adjust it confidently.

This is the shift from copying to understanding.

If we zoom out, the pattern is quite consistent.

You start by building a complete slice. Then you reproduce it to test your recall. Then you experiment to understand cause and effect. Then you isolate the parts that create friction. Finally, you modify the workflow and make it your own.

Again, the labels are not the most important thing.

The key is to always maintain an end-to-end feedback channel.

You are never just drifting. You always know what you are aiming for. You always have something working that tells you whether you are getting closer or moving further away.

This is especially important in the AI era.

AI can explain concepts, generate examples, summarize books, and help you debug problems very quickly. That is incredibly useful. But it can also make learning more passive. You can keep asking for more information without building anything yourself.

So the question is not whether information is available.

The question is whether you can turn that information into a structure that gives you feedback.

Because structure is what turns exposure into progress.

And once you learn how to build that structure for yourself, you can apply it to almost any skill.