Learning by doing: volume beats talent every time

How people actually learn a trade

Take a plumber.

You don’t become a plumber by reading one perfect book on plumbing and then installing a flawless system at the end of the year. You start by tightening pipes. You do it badly. You leak. You fix leaks. You do it again. Eventually, you don’t even think about how to seal a joint - your hands just do it.

Same for a carpenter. You don’t begin with a masterpiece table. You cut wood. You cut it wrong. You learn how wood behaves. After hundreds of cuts, you stop measuring every single thing because you feel what’s right.

Programming is no different.

You learn variables. Then loops. Then functions. Then you write terrible code. Then slightly less terrible code. If you’re lucky, someone more experienced looks at your work and tells you what you’re doing wrong - and why. Then you repeat the process at a higher level.

Learn X. Do X a lot. Get feedback. Learn Y. Do Y a lot.

That’s it. There is no shortcut.

The pottery class story

There’s a well-known story about a pottery class split into two groups.

Group A is graded on the quality of a single pot they make at the end.

Group B is graded on the quantity of pots they produce.

At the end of the course, the best pots come from Group B.

Why? Because while Group A was theorizing about perfection, Group B was producing volume. They failed more. They adjusted more. They learned faster. Volume didn’t just produce more pots - it produced better ones.

This is the core idea: quality is a side effect of volume.

What I see teaching programming

I teach coding at university. Every year, I see the same three types of students.

• The quick learners They understand the concepts immediately. They do the bare minimum. They get average grades.
• The grinders It doesn’t click right away. They struggle. They do the exercises anyway. They ask questions. They improve session after session. They get above-average grades.
• The tourists They don’t practice. They do something else during class. They disappear halfway through the semester. Sometimes I see them again the next year, in the same course. They get below-average grades.

The conclusion is uncomfortable but obvious: practice beats being “smart”.

I know this because I was student #1.

I understood everything quickly. I didn’t practice much. I did the minimum. University wasn’t what made me good. Work did. When I actually wanted (and needed) to perform, I practiced, a lot. That’s where most of my real skills came from.

Why volume works

When you do things in volume, you build automatism.

You don’t think about how to loop over an array. You just write it. You don’t think about variable scope. You feel when something is off. That frees mental space for harder problems.

If every small detail requires conscious effort, you can’t solve complex problems. Volume removes friction.

This is why, if I had to learn a new programming language tomorrow, I wouldn’t start with a big project. I’d start with 1,000 tiny exercises:

• Variables
• Conditions
• Loops
• Functions
• Simple classes

Only after that would I move to tooling, package managers, and projects. Again, gradually with a lot of repetition.

I’ve personally done a lot of Codewars and CodinGame katas. Simple stuff. Boring stuff. Effective stuff. Links: Codewars, CodinGame

The problem with learning resources

Here’s the issue: true beginner exercises are surprisingly hard to find.

Most platforms jump too quickly into “interesting” problems and skip the boring basics, the very things students need the most. Codewars is one of the few platforms I tolerate precisely because it has volume (even if it has terrible flaws).

For my web students learning HTML, CSS, JavaScript, and the DOM, I wasn’t satisfied with what existed. So I built my own set of katas and a sandbox:

Link: https://dtdg.fr/dom-katas/ (french only)

Right now there are about 40 katas. My real goal is 1,000.

From things as simple as adding an <h1> to a page, all the way to building dynamic lists with drag-and-drop using vanilla JavaScript and the DOM.

And I’m confident about this: a student who completes those 1,000 exercises will ace the class. Not because they’re smarter - but because they’ve done the work.

Final thought

If you want to learn something that actually matters, stop optimizing for elegance, cleverness, or motivation.

Those things feel good, but they don’t build skills.

What builds skills is volume. Repetition. Doing the same simple things often enough that they stop requiring conscious effort. When that happens, your brain is finally free to focus on harder problems, better designs, and higher-level thinking.

Most people avoid this phase because it’s boring, because it doesn’t look impressive, or because it doesn’t fit the romantic idea they have of learning. But every craft I’ve seen works the same way, whether it involves wood, pipes, or code.

If you’re willing to accept that and lean into it - if you’re willing to do a lot of unglamorous work on purpose - you don’t need to be exceptional.

You just need to show up and do the reps.