Start at the end: learning full stack development with AI

Start at the end: learning full stack development with AI

July 31, 2026

· softwarefull stack developmentspec-driven developmentdidactic prompting

In the past, when someone had an idea, they started coding it from line one. With AI coding agents, you can start at the end by building the entire project first. Bootstrap a project that interests you, then use it as your own personal sandbox. Learn by tweaking and tinkering, not wasting hours getting stuck.

In this article, I’ll take you through an example modern tech stack project, of the kind you might want to learn from across the frontend, backend, database and infrastructure, using the Full Stack Developer roadmap as a model. However, the principles apply to any stack and any project you can think of.

For my project, I decided on a simple idea called bestbooks.guide (GitHub). It’s a simple interactive website, with basic user features, like tracking which books you’ve read. It was easy to get up and running quickly, it’s something I’m interested in, and it can be extended in any number of ways.

The front page of bestbooks.guide

See Appendix A: Architecture Diagram for a detailed look at the bestbooks.guide tech stack.

Learning patterns

With the rate of progress of tech, software development requires lifelong learning, yet the rate of improvement in AI has made this increasingly daunting. Being able to generate limitless code is a good thing and a bad thing: there have never been more opportunities for learning, and yet more opportunities for complacency.

There are three main ways of learning that I think should be combined to learn anything properly:

Learning by observing - watching lectures or courses, reading textbooks, listening to podcasts. The material should be substantive and good quality, which will require deep mental focus and effort. If the material is too easy, it could be a sign that it’s oversimplifying things, which can lull you into a false sense of security and teach bad habits1.

Find high-quality, authoritative sources of information to learn from, so that you don’t waste your time. You should find the material engaging and intellectually meaningful so that you will finish it. Avoid “content producers” on YouTube.

It’s also critical that you do not remain passive while absorbing the material, so that it is retained. This is where the other learning patterns come into play.

Learning by writing - what’s come to be called the Feynman technique2. Writing notes is an effective way to retain information, if done in frequent small doses, and used to test your own understanding3. Write what you’re learning in your own words and test you remember it.

I like using markdown .md files and git for my note taking. This in itself is good practice for using version control effectively. The added bonus is that your notes are backed up and have an immutable version history. You can track your progress, hold yourself more accountable, but in any case your efforts will be rewarded with an artefact that you should feel proud of producing.

Use notes to test your memory and form habits, not just to copy verbatim. Often the reference you are learning from is a better source of information than your own notes - the benefit is in the writing rather than the utility.

Learning by doing - putting things into practice is final confirmation that you understand something. Many of us like to jump to doing things immediately, and this post is in that spirit - I would only caution that for something as cerebral as software engineering, you need to combine it with theory and reading. While we’re going to start at the end, we’re not finishing at the end.

If you’re following a course or reading a textbook, do the exercises. In addition to writing notes, I like to fold exercise solutions into my markdown repositories too.

Start small and avoid heavy chores. If you get excited about a website or app idea that you want to build, think about how quickly you can ship it.

graph LR A[Learning by observing] -->|retained by| B[Learning by writing] B -->|practiced by| C[Learning by doing] C -->|enhanced by| A

Roadmaps

One great source of learning material is roadmap.sh.

The roadmaps are deliberately comprehensive. Each roadmap demonstrates all the key points to know about a role or skill, and lets you track your progress. You can be confident you’ve learned everything that matters, which comes to fruition whether you’re attending job interviews or designing architecture.

While textbooks are a superb resource, they are linear, even when they are designed to be references. roadmap.sh maps out a hierarchy of topics and learning resources, so you can see at a glance what you know and don’t know, then deep dive into resources.

A good strategy for learning anything about software or computers is to pick the roadmap that fits what you want to learn, and then apply the learning strategy above while you work through it.

Each node in a roadmap comes with example free resources. The idea is to complete one or two of these free resources, or find your own, applying all three learning patterns, then move onto the next node in the roadmap. Again I’d recommend making a repository that collects your notes, exercises and projects completed while learning the roadmap. This will help you to come up with your own “definition of done” that feels more meaningful than just reading to the end.

For this article, I’m using the Full Stack Developer roadmap. It’s beginner-friendly and generalisable to many developers.

How to use a computer

The focus of this article is on learning full stack dev by bootstrapping a project that interests you, with the power of AI coding agents. However, you are still required to use a computer Actually you can already get Claude Code to submit pull requests via voice command from your phone, but I digress. . If you are new to software development, there may be some tasks I take for granted that seem impenetrable for you.

To remedy this I would recommend a dose of therapy using the Unix philosophy, and installing a Unix-like operating system on your desktop computer such as Linux. Thankfully there are options for home treatment:

MIT’s Missing Semester of Your CS Education is a fantastic resource on how to use a computer. Now, although it’s an introductory course, it is designed for the world’s brightest undergraduate computer science students. Try it first and see if it sticks, but don’t be dismayed if this is still over your head.

If you don’t like Missing Semester, there are roadmaps on roadmap.sh that cover the key skills we’re interested in. Again, these are comprehensive roadmaps, so you don’t need to fully complete these to get started. Try some of the free resources listed under the introductions in these roadmaps, or find your own:

Linux

Shell / Bash

Git and GitHub

If you want to carry on using Windows desktop, installing Visual Studio Code is a good first step It would be remiss of me not to mention that you can also install Linux within Windows using WSL. However, my advice is to simplify your desktop for ease of use, and I don’t think blending two different operating systems is the way to do that. .

The reason I recommend Unix philosophy is that learning small, composable programs4 lends itself towards having a composable mind, with a skillset tailored for software engineering. Understanding the “everything is a file” approach for program interfaces makes seemingly impossible feats straightforward and understandable5.

Understanding how to manipulate simple and composable programs compounds over time, because this is literally how a coding agent harness like Claude Code works. If you have watched Claude Code at work and its use of tools confounds you, it is probably because you missed the fundamentals laid out above.

AI coding tools

At the time of writing, we’re in a period where AI models are advancing very rapidly. Models that were fairly rubbish a year or two ago now have successors that are pretty good. Frontier models are astonishingly good6.

I want to briefly mention the distinction between AI models, which are the mysterious enigmas where all the magic happens, and agentic coding harnesses, which are handwritten tools that babysit and coax the model into following a useful agentic workflow that persists over time. For example, Claude Opus is a model, and Claude Code is a harness.

If you’re new to this, I personally recommend Claude Code at the time of writing. The CLI tool is good, so is the VS Code plugin and the Claude Desktop app. However, there are several other competitive tools, like GitHub Copilot and Cursor, and the best tool is likely to change over time. There is a good Claude Code roadmap that will guide you through all its features. You don’t need to know everything, but understanding what is meant by context window management is a good start. I have completed this roadmap myself and recommend it.

In terms of models, we’re at a point where paying more money for a better model will get much better results. In the near future, I think open weight models that you run on your own laptop will be more than good enough. We’ve gone back to the mainframe computer era and we will enter the portable era again soon. In fact you can already do this, but we’re not quite at the point where it’s the best or most cost-effective option (a good GPU will set you back a bit). You may be aware that coding agents can make mistakes and hallucinate7. This has rapidly diminished as models have got better. If you’ve opted for Claude Code, I’d recommend you use it with the Opus or Fable models rather than Sonnet for this reason. A standard Pro subscription will get you a good amount of use out of Opus, but pay for what you can afford.

Bootstrapping your full stack project

If you have any experience with software development, you probably know how much of a problem yak shaving is. If you’ve got this far, you’re either already an experienced developer (congrats), or I sent you down several rabbit holes.

I’m actually trying to help. My proposal is that we can start the Full Stack Developer roadmap by first completing it, using AI coding agents. Then we can dive deeper into each of the key technologies making up this stack, which includes React, Node.js, PostgreSQL, AWS and Terraform.

If you’re comfortable, ask your AI coding agent or chatbot for suitable project ideas using the full tech stack in the roadmap. Ask it for ideas that are quick to ship and have the least chores to build and maintain. Pick the idea that most excites you. Games can be a bad idea for practising code. The code might be simple, but then you spend three months on art assets, gameplay and level design. This is no longer a targeted learning exercise, it’s a multi-disciplinary and time-consuming passion project. Understand what you’re getting into.

If you need smaller steps, look at the roadmap’s checkpoints. Ask Claude for ideas for a simple HTML/CSS static website, that demonstrates all the key features of HTML and CSS, without requiring other technologies. A blog is simple and useful.

Spec-Driven Development (SDD)

It’s not strictly required, but to get the most out of AI I recommend following spec-driven development (SDD). I like to call it plan-first development, because you write a plan first before you code anything.

This is emerging as one of the more widely adopted techniques in AI-assisted software development8. Claude Code comes with a Plan Mode9 for precisely this reason, and it’s intended that you use it to draft an agreed plan before you commit to a specific implementation.

I don’t want you to keep the plan private between yourself and Claude though: I want you to commit the plan to your project, in a /docs folder, living side-by-side with the code.

There are a few reasons I recommend it for our purposes:

You can get involved in understanding plans before you can write any code.

[truncated for AI cost control]