How to Keep Learning When Agents Can Generate the Tutorial

A practical argument for running the example, changing it, and seeing what breaks instead of stopping at plausible output.

Why am I still writing tutorials when agents can generate them?

Because generated output is not the same thing as understanding, and I do not think developers should give up on understanding.

That probably sounds obvious until you look at how people actually talk about agent tooling right now. The speed is real. The convenience is real. The blank page disappears. You ask for a service, a workflow, a UI, or a full walkthrough, and something plausible shows up in a minute or two. If you only measure output, this looks like the end of the tutorial as a learning format.

I do not think that conclusion holds up very well.

The Wrong Conclusion

I live in a bit of a bubble. Usually that means I spend time thinking through things before they hit the mainstream or become relevant to enterprise customers. That does not make the bubble special. It mostly means I get to watch the tunnel vision arrive a little early. We have seen this before with other technologies. Hype sells. Hype narrows attention. Hype is very good at making one capability look like the whole story.

That is where I think some of the current agent talk is going wrong.

I keep hearing some version of “nobody learns this way anymore.” Sometimes that means tutorials. Sometimes it means books. Sometimes it means sitting down long enough to work through an example without outsourcing all of the friction. The sentence is usually presented as a practical observation. I think it is also a lazy one.

The stronger version is worse. It quietly suggests that maybe nobody really needs to learn anymore, because the agent can scaffold the app, generate the tests, explain the code, and write the tutorial too. At that point we are no longer talking about speed. We are talking about whether understanding still matters.

For me, it does.

To be clear, I am not pretending agents are a toy. They are useful. I use them. They remove a lot of blank-page pain. They help with mechanics. They are often very good at getting the first version of something on the screen, which is not nothing. I would rather start from a decent generated base than from an empty editor and false moral purity about doing everything by hand.

But a decent generated base is still just a base.

The Part Agents Skip

The part that gets lost in the current conversation is that a lot of software work stops being “just programming” very quickly. The nice demo usually ends right before the problem becomes real. Configuration starts to pile up. Deployment constraints show up. Security rules arrive. Operations has opinions. Performance stops being theoretical. The business asks for behavior that sounded harmless in a meeting and slowly turns into Excel on the web. None of this is exotic. This is normal.

Agents can help you produce code that participates in those systems. They do not automatically give you a working mental model of the systems themselves.

That difference matters even more when the complexity lives between layers. The hard part is often not the endpoint, the class, or the prompt. The hard part is the combined mess of configuration, DevOps, infrastructure, runtime behavior, and team assumptions around it. Those are the parts developers only really understand when they experience them. A generated happy path can get you started. It does not save you from having to learn where the happy path ends.

That is one reason I still write tutorials, and one reason I still use them.

Why Tutorials Still Matter

I still learn through tutorials. Not because I need somebody to type for me, but because a good tutorial gives me a structured way to build a mental model. It gives me a starting point, a direction, and a bounded piece of reality I can actually push on. The useful part is not copying the example. The useful part starts right after that.

Run it. Change it. See what breaks.

That is still one of the best ways to learn anything technical.

If a tutorial is good, it does more than move you from one code block to the next. It gives you a system you can disturb. You change one assumption. You swap one component. You misconfigure one thing on purpose. You push the example a little past the happy path and watch where the cracks show up. That is the moment where understanding starts to become yours instead of borrowed.

That is also what I mean by playing. Not vague tinkering. Change the example and see what breaks.

This is also why I do not find agent-generated end-to-end tutorials especially convincing on their own. They often cover the mechanics. They often miss the business reason, the ugly trade-off, or the boring operational constraint that made the problem worth solving in the first place. If they do include business context, it is often suspiciously neat. Real teams are usually less elegant than that.

I do not need another beautifully structured demo that quietly assumes clean inputs, stable infrastructure, and reasonable product requests. I need material that survives contact with systems people actually have to run.

This is where the “nobody learns this way anymore” line starts to annoy me.

What does that sentence even mean in practice? That nobody sits with an example long enough to understand it? That nobody follows a tutorial and changes it until it stops behaving? That nobody needs the time it takes to connect a generated answer to a real mental model?

If that is really the claim, then the problem is not tutorials. The problem is that we are getting too comfortable with plausible output.

And plausible output is dangerous in exactly the places where senior developers are supposed to be useful.

Attention Is Part of the Job

The more agent-driven our workflows become, the more we need review, judgment, and the ability to tell the difference between “this runs” and “this makes sense.” I am careful with that claim because I do not want to oversell tutorials as some magical cure. Working through a tutorial does not automatically turn anyone into a great reviewer. But it does train some of the same habits.

You compare intent with behavior.

You notice where your assumptions were wrong.

You inspect what changed after one small modification.

You learn to spot where the happy path was hiding complexity.

That is review work in a smaller and friendlier container.

It is also attention training, which sounds softer than I mean it.

One of the strangest side effects of agent tooling is that it can make developers feel informed while skipping the part where they actually sit with the problem. The machine keeps producing movement. Files change. Tests run. A draft appears. A second draft appears faster. It is very easy to confuse momentum with learning.

Tutorials are useful partly because they interrupt that illusion.

They force you to spend time with one thing for longer than the current tooling culture finds fashionable. You have to read. You have to run the code. You have to change the example. You have to pay attention to what the system is actually doing. In a world that keeps pushing speed as the primary virtue, that kind of deliberate slowness is not a bug. It is a way to stay awake.

And yes, I do think staying alert is part of the job now.

Staying alert means better filters. More patience. Stronger fundamentals. More skepticism when a generated answer looks a little too clean. It also means getting better at ignoring noise. The fast-moving part of the industry is very good at making every new workflow sound total. It rarely is. Most useful things arrive as additions, not replacements.

That is another reason I still publish normal developer tutorials.

I am not trying to defend an old format out of sentimentality. I am trying to protect one of the few learning modes that still forces understanding to show up. A good tutorial does not compete with agents by being slower at generation. It does a different job. It helps developers build enough judgment to use agents without turning into passive operators of their own toolchain.

I also think it is worth saying this plainly: if we stop learning on purpose because agents got fast, we are not becoming more advanced. We are becoming more dependent on outputs we may no longer know how to judge.

That is not a future I find especially impressive.

Learn on Purpose

So yes, I am still writing tutorials. I am still reading them. I am still working through examples and changing them until something breaks. I expect agents to stay. I expect them to get better. I also expect deliberate learning to matter more, not less, because speed keeps removing the natural friction that used to expose shallow understanding.

If you want the practical version, it is simple.

Use agents.

Use the speed.

But still sit with the tutorial.

Run it.

Change it.

Break it.

Review it.

Learn on purpose.