Learning by Building

In education we’ve long had the idea of a capstone. At the end of a program, whether that’s a four-year degree, a master’s degree, certificates, short courses, or corporate learning and development seminars, there’s usually some applied exercise that pulls together everything from the courses that came before it. For decades this has been a learning-by-doing exercise. A simulation, run in a classroom, that gives students a sense of applying their knowledge practically while still keeping them in a safe environment. I don’t think this is a useful way of organizing learning anymore.

The reason is that the exercises and simulations we used to run in these situations can now all be done by AI. AI can write better essays than most college students. It can answer multiple choice questions, and while we’re here, please stop conducting multiple choice exams in online environments—they are now completely useless. Claude produces pretty good slides, especially as summaries of manuscripts I’m working on. It can produce audio and video presentations. It can create the wireframes and the mockups and basically every other artifact we used to ask for in these exercises. So the capstones as we used to do them doesn’t represent a useful form of learning any longer.

So what does? Here’s my argument: what constitutes a useful form of learning now is what I’d call learning by building. It’s similar to learning by doing in a lot of ways. The difference is that you’re building something real. My proposal, especially for higher education and for postgraduate and lifelong learning in industry settings, is that learning by building starts with identifying real problems together with other people. People in industry, in civil society, in government. Or your clients, your family, or your local community. You need to spend time understanding what problems they are experiencing so that you can start building solutions to them with AI.

Vibe coding has enabled people to do things they couldn’t do before. I find myself doing things I previously did not have the technical skills for. For example, I set up my own home server recently. In a pre-LLM world I estimate that would have taken me a full weekend of work, and as the parent of two preschoolers, I don’t have a full weekend. I did it in forty-five minutes while cooking dinner for my boys. Working with Claude enabled me to do this, and it is possible because of two capacities of LLMs, as explained by a recent paper with a catchy title: “Position: LLMs can’t jump.”

The first capacity is synthesis, or induction. In situations where there’s a lot of knowledge about something, where somebody knows a lot about it and I don’t, LLMs are excellent at compiling that knowledge. You can think of it as a supercharged search engine. I find this enormously helpful in the many situations where something is difficult for me but not difficult for other people. The information is out there, and the model compresses all of it and presents it to me.

The second is extrapolation, or deduction. The model can work out from a set of premises what should come next. This is what’s happening when Claude Code generates a software architecture and then starts writing the code for it. Claude is extrapolating, and it can build pretty cool artifacts doing it.

The papers’ argument, and the reason for its title, is that these two capacities also form the limit to what LLMs can do. A third mode of inference, abduction, the leap from a surprising observation to a new explanation for it, is something LLMs can’t do. That’s the jump. An LLM can synthesize what’s known and extrapolate from what you give it, but it won’t hand you the problem, nor can it provide a counter-intuitive reframing that allows you to see the problem in a genuinely new light (yes, I typed out that “genuinely” myself!).

Between them, the two capacities of induction and deduction lets LLMs help me research and learn new things, and also create new things extrapolated from my imagination and from the context I provide the model. That’s what makes learning by building possible.

In my view of learning by building, you’re building artifacts that help you solve the problem at hand. You’re communicating continuously with your stakeholders while you do it. And then at the end you try to implement your prototype together with them, which is what gives you feedback from actual humans, communities, and organizations. That’s what lets you build things that are real, that make a difference in the world, and that you couldn’t have built before.

And while you’re doing all this, there are things you have to figure out. The LLM can’t do it all by itself. You have to make choices, which means you have to learn. What happens is that you build up a learning spine. You’ve got these blanks that need filling, and the AI can explain the concepts and point you toward a study guide: articles to read, audio to listen to, podcasts, videos, or custom-made versions of all of it through something like NotebookLM. This means that the question to solve a problem through building an artifact produces a learning journey, rather than being a grand finale at the end of the journey.

Learning by building is an inversion of the traditional structure. You start with the capstone, and then you run the capstone throughout the entire program, so that you’re always grounding what you’re learning in a real problem you’re trying to solve and in a building process that’s already underway. You start with the capstone on day one, and you never stop. This process then suggests knowledge that you will need throughout, but what specific knowledge is needed is emergent, based on what problem you are solving and what artifact you are building.

Higher education needs to change to adapt to this, and so does adult learning, whether it happens in corporations or other postgraduate learning environments. Busy times head!