Start at the end: learning full stack development with AI | George Stephenson

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<br>A[Learning by observing] -->|retained by| B[Learning by writing]<br>B -->|practiced by| C[Learning by doing]<br>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...