Skip to main content
Text ready — video coming soon

The Thesis: Solve Problems by Doing What AI Can't, and Asking It to Do What It Can

Hello! This is the Thesis: the page where the book makes its whole argument.

If you came here from the Welcome page, you already have the idea in one line: solve problems by doing what AI can't, and asking it to do what it can. This page makes the full case for that idea, with the evidence behind it.

It is written for readers who already know a little about software. Perhaps you have written some code, used an app builder, or asked an AI to build something for you. If none of that is true yet, you are still welcome here. Some parts will feel hard, and that is expected: in Stage 0, I start from the very basics and teach what each idea on this page means and what it is for.

On this page, you will see:

  • What changed: AI can now make almost anything, from code to music
  • The two movements: from development to engineering, and from products to solutions
  • The two paths to a solution: using agentic AI and building it
  • Why vibe coding and vibe decisioning still fail, and why your value can drop even when the AI's doesn't
  • The three steps the whole book is built on
  • The five skills you will learn, why problem solving is a mindset, and how deep each topic goes
  • How you will work with AI: Spec-Driven Engineering, the book's method
  • The three ways to get it wrong, with two real incidents

This page matters because it decides how you spend your next few years of learning. Every topic in the book is chosen, and shaped, by the argument on this page.

What changed: AI can now make almost anything​

AI can now write code, research, design, and create images, videos and music. So the question is no longer can you make things, but can you solve problems people will pay to have solved.

Here is where things stand:

  • Code. At Google, about three quarters of all new code is now generated by AI and approved by its engineers, up from half about six months earlier (Sundar Pichai, Google's CEO, April 2026).
  • Images. People have made more than 50 billion images with Nano Banana, Google's image model (Sundar Pichai, Google I/O, May 2026).
  • Music. Suno, a company whose AI writes a whole song from a short description, raised $400 million at a value of $5.4 billion (reported by Built In, June 2026).
  • Longer work. METR is a research group that measures how long a task takes a skilled person, then finds the longest tasks the best models complete about half the time. Since 2023, that length has doubled roughly every four months (METR, January 2026).
  • Fast adoption. Within three years, generative AI reached 53% of people, faster than the personal computer or the internet did, and 88% of organisations have adopted AI (Stanford AI Index, 2026).

There is a closer example, too. The platform you are reading was built by AI coding agents, AI tools that write and run code, but it was not vibe coded. I built it with Spec-Driven Engineering, the method this book teaches: deciding what should be built and what must never happen, setting the limits the AI worked inside, and checking its work. It works, and you are using it right now.

So making things is no longer the hard part. What stays hard is knowing which problem is worth solving, and solving it well enough that people trust you with it. That is what the rest of this page is about.

The two movements: from development to engineering, and from products to solutions​

The book is built on two shifts, and they matter equally.

From development to engineering. Development is producing the code. Engineering is the judgment around it: what should be built, what must never happen, and checking that it really works. AI now does much of the development, so your value moves to the engineering. This page makes the full case for it later, in the section on Spec-Driven Engineering.

From products to solutions. A product is a thing you make. A solution is a real person's problem, solved. When AI can make the thing in an afternoon, the thing alone is worth less, and the problem taken away is worth more. A café owner doesn't really want a website; they want customers who can find the menu and order. A clinic doesn't really want an agent; it wants patients who get an answer at midnight.

So the old target was to become an engineer instead of a developer. The new target is to become an Agentic AI Solution Engineer: someone who can find a real problem, solve it with agentic AI, and sell the solution on their own, whether they work for themselves or inside a company.

Engineering is the biggest part of that, and this page spends most of its length there. But it is not the whole of it.

The two paths to a solution: using agentic AI and building it​

Agentic AI is AI that plans its steps and uses tools to finish a job, not only answer. There are two ways to solve a problem with it:

The pathWhat you doAn example
Using agentic AIYou direct AI agents that already exist, and they help you build the solutionA café in Islamabad needs customers to see its menu and order online. You use AI coding agents to build its website. The website has no AI inside it, but agentic AI helped make it
Building agentic AIYou build a new AI agent, and the agent is the solutionA clinic in Lahore loses patients because nobody answers messages after hours. You build an agent that replies on WhatsApp and books appointments

Building sits inside using. To build the clinic's agent, you still direct AI coding agents to write much of it. And building one agent teaches you how all of them work, which makes you better at using them. Both paths end in the same place: a person whose problem is gone.

Why vibe coding still fails at a bigger level​

Making things easily has a trap. Vibe coding is building software by describing it to an AI and accepting what comes back, without reading the code. The term was coined in February 2025, and before the year was out it was Collins Dictionary's Word of the Year.

For small things, vibe coding often works. The problem is that it fails at a bigger and higher level, where the stakes are real:

  • Security. In tests across many AI models, about 44% of coding tasks produced code with a well-known kind of security flaw. The AI was given no security instructions, and the newest, smartest models were barely better than older ones (Veracode, July 2026).
  • Real apps with real users. A scan of about 5,600 live apps built by vibe coding, most of them on one platform, found more than 2,000 security holes. It also found more than 400 exposed secret keys, and personal data, including bank details, open to anyone who looked (Escape.tech, October 2025).
  • Growth. As AI coding tools spread, the share of copied-and-pasted code rose and the work of tidying and reusing code fell (GitClear, 2025). Copied code is harder to change safely, because every copy has to be found and fixed.

Being small does not make an app safe. A tiny app that holds people's bank details can still leak them, and for those people the harm is just as real. What decides the danger is what the app holds, and how far the damage can reach when something goes wrong.

Why the real risk is no longer only the code, but the decisions​

The AI may now write much of the code correctly. But code is only part of the job. An old idea from business strategy explains the rest. The software writer Joel Spolsky described it this way: when the price of a product's complements falls, demand for the product rises. A complement is simply something used together with it, like petrol for a car. When making gets cheap, solving gets valuable.

Code is getting cheaper, but not all code is cheap yet. Everyday code, the kind beginner and intermediate developers write, now costs very little to produce. The code behind complex agentic AI and other advanced systems is still expensive, though it gets cheaper over time. So it is not enough to move forward. You have to move higher, toward the work that is still hard.

Around all code sit decisions that take real problem solving and critical thinking. They are different in every solution, and they need someone who understands the problem, the people and the technology, and who will answer for the choice. Making them by feel, or accepting whatever the AI chose, has a name: vibe decisioning. I arrived at this term independently, and only later learned that the analyst David Pidsley had used it first, in 2025, for building decision systems by prompting AI. This book uses it more widely: making decisions blindly, or accepting the AI's, without checking them or knowing what will follow.

The answer is not to compete with the AI. Nobody wins that race, and nobody needs to run it. The answer is to work with it, knowing enough to make each decision better than the AI could alone.

Why your value can drop even when the AI's value doesn't​

Here is the part most students miss. If you can use AI without adding anything of your own, so can everyone else. Other people have the same AI you have, and some have a better model on a bigger plan. The value the AI gives does not drop. Yours does.

Companies already work this way. In April 2025, the head of Shopify, a large online-shop company, told his teams that before asking to hire more people, they must show why AI cannot do the work. A few months earlier, the head of Salesforce said it would add no more software engineers that year, because AI had raised its engineers' productivity by more than 30%. And the price gap is wide: the most powerful AI coding plans cost about $100 to $500 a month, while the typical software developer in the United States earns about $136,000 a year (US Bureau of Labor Statistics).

You can see a shift in hiring, too. In the United States, employment of young software developers, aged 22 to 25, fell by nearly a fifth from its peak in late 2022, and one of the researchers behind that figure says AI probably does not explain all of it (Stanford Digital Economy Lab). Early in 2026, senior roles were about 69% of software job postings on Indeed, one of the largest job sites, and entry-level roles only about 4.5% (Indeed Hiring Lab, July 2026).

So the rule is simple. The AI is paid, and is already being paid, for the work the AI can do. You will be paid for the work you can do.

That is why two questions decide your future:

What value do I add, using AI, that the AI can't add alone?

Whose problem am I solving, and will they pay to have it solved?

The first keeps your work worth something. The second makes sure someone needs it.

Today, AI gives real value at the beginner and intermediate levels of software work. At the advanced level, it still cannot do everything alone. Most developers do not yet trust it with putting live software online and watching over it, or with planning projects (Stack Overflow Developer Survey, 2025). At that level, the work needs a human. Be that human. The line keeps moving up, which is why finding it again, every time the tools change, is the first step of this book.

Why the problem is also your opportunity​

If AI can now make so much, that is not only a threat. It is the opportunity of your career, in three ways:

  • Use AI better than others, at the level it handles. Most people use the same tools carelessly. Using them well, fast and safely, already puts you ahead.
  • Master the higher level, where the AI needs you. The person who can make the decisions the AI can't make alone is the person worth hiring.
  • Solve problems nobody has solved for people yet. Small businesses are taking up AI more slowly than large ones: in the United States, 17% of firms with fewer than 20 employees use AI, against 30% of firms with 250 or more (Federal Reserve Bank of Minneapolis, May 2026). Most small businesses will never hire an AI team. They need someone who understands their problem and can solve it.

Companies are hiring for this, too. Job postings for forward-deployed engineers, who work beside a customer to solve their problem with AI, rose by more than 1,000% between January and August 2026, compared with the same months a year earlier (Lightcast, reported by Fortune, September 2026).

This works on your own and inside a company. A freelancer finds the café's problem; an engineer in a company finds the problem inside their own team. And the same holds outside work: wherever you use AI in your own life, the value is in what you bring to it.

Why the line between AI's work and yours is uneven, and keeps moving​

If AI is strong at some work and weak at other work, you might expect a clean line: easy tasks for AI, hard tasks for people. The real line is messier than that.

In a well-known study, 758 consultants at Boston Consulting Group, a large business advice company, did realistic work tasks. Some used AI and some did not (Harvard Business School, 2023). The results depended on the task:

The kind of taskPeople using AI, compared with people working alone
Tasks AI is good atThey finished 12.2% more tasks, worked 25.1% faster, and did work more than 40% better
Tasks just outside what AI is good atThey got the right answer less often: about 19 fewer people in every 100 got it right

So the line between what AI does well and what it doesn't is uneven. Two tasks that look equally hard can sit on opposite sides of it, and nothing warns you which side you are on. The biggest danger with AI is confident output on the wrong side of the line, because nothing about it looks wrong.

And the line moves. In early 2025, a careful study found that experienced developers finished real tasks about 19% more slowly when they used AI tools, even though they believed AI had made them about 20% faster. A year later, the same research group reported that developers were now probably faster with AI, and that many of them would no longer agree to work without it. It called its new data only very weak evidence of how much faster they were (METR, February 2026).

So any fixed list of "things AI can't do" goes out of date. The lasting skill is finding the line again, on your own work, every time the tools change.

The three steps the whole book is built on​

Put those sections together, and the book's whole philosophy comes out in three steps, taken again for every problem you solve:

  1. Identify what AI can do for this problem, and what it can't.
  2. Master what it can't, by understanding it, learning it properly and getting good at it. Get to know what it can, well enough to judge its work.
  3. Use AI for everything it can do.

Step 1 never finishes, because the line keeps moving. In Stage 0, you read examples of AI-written code and check what they do. The later courses are planned around the same questions. What can AI do for this task? What must you understand and decide yourself?

What you will learn: five skills, and how they fit together​

The three steps decide how you learn. Five skills decide what you learn:

The skillWhat it coversWhere it sits in this book
Software engineeringThe foundations: programming, planning a system's structure, data, testing and putting software onlineUnder the hood
Building agentic AIAI agents of your ownUnder the hood
Using AI at an expert levelDirecting AI coding agents and AI systems to build real things, quickly and safelyOn top, holding the three under the hood
Advanced web developmentBuilding the websites and apps people meet AI through, taken to an advanced levelUnder the hood
Problem solving and earningFinding a problem worth solving, understanding the people who have it, designing the solution, and explaining and selling itAround the other four

You can only direct AI as well as you understand what it is doing. Someone who knows no engineering can ask an AI for an app, but cannot tell a sound design from a fragile one. Someone who has never built an agent can use AI tools, but cannot make new ones. Someone who has never built the website or app around an AI cannot put it in other people's hands. And none of it is worth much if it solves nobody's problem: the fifth skill points the other four at something people need.

The skills are also closer than they look. An AI agent is ordinary software with an AI model inside it:

  • the functions you write in your first programs become the tools an agent calls
  • a loop becomes the agent's loop of thinking and acting
  • a database becomes its memory
  • permissions become what it is allowed to touch

So learning software engineering well is already a large part of learning to build agents.

Web development is where all of it meets people. Almost everything people touch an AI through is on the web: the chat window, the dashboard, the page where you sign in. That is why it has a place of its own, and why the book takes it to an advanced level.

This is also what AI-native means in this book. Other places use the word more narrowly. Here it covers four ways of working with AI:

  • Using AI: directing AI tools to do real work
  • Building AI: making agents of your own
  • Building for AI: making things that AI uses, such as MCP servers, small programs that give an agent a new ability
  • Adding AI to ordinary software: putting AI inside a system that is not AI itself. This site is one example: an ordinary documentation website, with an AI tutor being built into it

Why problem solving is a mindset, not a tool​

Problem solving is not one more tool on the list. It is the way of thinking that runs through all five skills. It covers four areas:

The areaWhat it asks
Finding the problemWhat is really wrong, and for whom? Is it worth solving?
Understanding peopleWhat do they need, what have they already tried, and what would they trust?
Research and designWhat do we know, what are the options, and which one fits the limits?
Communication and sellingCan you explain the solution so the person sees its value, and decides to use it or pay for it?

Every solution has two sides. The business side asks whose problem it is, what solving it is worth to them, and how the solution reaches them. The technical side asks how to build it so it works, stays safe and keeps working. Spec-Driven Engineering, the method later on this page, lives on the technical side.

The same mindset runs through both sides. Writing a good specification is already problem solving: before anything is built, you name the problem, the people, the limits and how you will know it works. And the problem can be of any kind: a bug, a slow website, a clinic that loses patients, or a shop that can't reach its customers. The tools change; the way of thinking stays the same.

Lessons that teach this skill directly are still being planned.

Why and how deep: every topic stays, learned for a reason​

If AI writes the code, you might wonder whether Python, JavaScript, databases or agents still need to be learned at all. They do, every one of them. You cannot decide whether a solution needs an AI that searches its documents, which tools an agent may use, or whether an AI's design is wrong, without understanding the thing itself. Knowledge is the raw material of judgment.

What changes is two things: why each topic is learned, and how deep. For every topic, the book asks which decisions you need to understand and what AI can reliably do with the tools available. Depth runs from 0.1 to 3.0, in steps of 0.1. These landmarks describe the understanding expected, not a grade:

DepthWhat it asks of you
0.5Recognise that something exists and what it is for
1.0Understand its purpose and judge a visible result; Stage 0 introduces ideas at this exposure level
1.3Read common code line by line, predict its result and spot obvious bugs; Course 1's Python target
1.5Recognise a tool's main building blocks and follow one run through them
2.0Steer AI through the work and check its choices
2.5Design the work and teach the reasoning
3.0Own the topic at full depth, including its difficult cases

This changes how you practise, too. Less memorising of syntax, the exact spelling and grammar of code. More reading, predicting, tracing, designing, choosing, testing and explaining. AI writes the implementation; you specify it, inspect it and verify the result. Responsibility belongs to you at every depth; it does not wait for 3.0.

If AI can make a decision better than you, why learn it at all?​

Here is an honest fact: AI now makes many beginner and intermediate engineering decisions well, often better than a beginner would. So why learn something the AI does better, and why not skip the lower layers and start at the top? There are three answers.

1. A decision at the top rests on everything underneath it. To choose well at any level, you need to understand the cause and effect below it: what happens if this changes, and what breaks if that fails. That does not mean spending months doing by hand what the AI does in seconds. It means never being completely blind to how the work is done.

2. The best opportunities go to real expertise. If you know nothing about something the AI can do, you are competing with the AI. If you understand it deeply, the AI becomes your tool instead of your competition.

3. You can only explain what you have ideas and words for, to a person or to an AI. Imagine trying to convince someone that a war is a terrible thing. You may feel it strongly, but to make them understand, you need the ideas behind the feeling: the people caught in it, the cost to the country's economy, the cities destroyed and rebuilt, and the damage that lasts for decades. Without them, all you can say is "it's bad." The same is true when you explain a solution to a client, or a task to an AI. An AI can only follow what you can say. A specification is exactly this: your understanding, written down in precise words.

How you will work with AI: Spec-Driven Engineering​

Spec-Driven Engineering is the technical side of solving a problem. To see it, split software work into two layers:

  • Development is producing the code: the working lines themselves. AI now does this well, often better than people.
  • Engineering is the judgment around the code: what should be built, what may change, how a failure is contained, and who owns the result. This is where your value lies.

Development still has to be understood, because you cannot check work you cannot follow. It is simply no longer where your value comes from.

This has happened before. In the late 1800s and early 1900s, oil, electricity and new machines changed how the world worked, and machines took over much of the heavy work people had done by hand. In the United States, the share of workers on farms fell from about half to under a third in just forty years. Engineers did not disappear. Their number in the US roughly tripled in twenty years, from about 28,000 to about 89,000, and more than a hundred years later, engineering jobs are still growing (US Bureau of Labor Statistics). Development changes, and sometimes dies. Engineering lasts.

So what is an engineer? The word comes from the Latin ingenium, meaning natural talent or cleverness. It is where the word ingenious comes from, too. An engineer is someone who uses that cleverness to solve real problems within real limits, and answers for the result. If engineer becomes part of who you are, not just a job title, then whatever the tools do next, the key stays in your hands.

Think of building a house. The mistri, the skilled builder you hire in Pakistan to put up a house, can build whatever you point at, and fast. That is the AI. The house plan, drawn before the first brick, is the software architecture and the specification: the decisions that are expensive to change later. Checking that the pillars really have steel inside is verification. And adding a second floor years later, on a foundation nobody planned for it, is technical debt: the cost of today's shortcuts, paid later with interest.

Here is where the picture breaks. Cracks in a house show. Debt in software stays invisible until something fails.

Spec-Driven Engineering, or SDE, turns this into four moves:

The moveWho does itWhat it means
SpecifyYouWrite down what should be built, what must never change, and how you will know it works
BuildThe AIWrite the code inside those limits, faster than you could
VerifyYouJudge and challenge the work while the AI is doing it, not only after: how it is building, and the core of what it builds, checked against your spec. Never against how confident the AI sounds
OwnYouDecide that it is right, and answer for it from then on

Verifying happens during the work, not after it. While the AI works, you judge and challenge the approach it chose, the core of what it writes, and what it is about to touch. To do that in the moment, you must master the core implementation yourself: the things the AI is doing, not just what comes out at the end.

Verifying needs Code Literacy: reading and judging code. In this book, that means reading the decisions and the evidence: what the AI decided, what changed, what the checks reported, and what you now own. And it means being able to read the actual lines whenever you need to.

Technical debt is the cost this method exists to control. Ward Cunningham, the engineer who coined the term, compared shipping first-draft code to borrowing money: a little debt speeds you up, as long as you pay it back soon. Vibe coding borrows without knowing it has borrowed. In my reading of the research, debt in the architecture is the most expensive kind, because it is the hardest to see and the widest to fix.

Where SDE comes from, and what it adds​

Spec-driven development, or SDD, describes approaches that organise development around a written specification. GitHub's Spec Kit is one documented approach: the spec guides planning, tasks and implementation, and changes with the work. Different teams and tools apply SDD differently.

Spec-Driven Engineering is this book's own name, built on that work. Here, it makes the wider engineering responsibilities explicit: deciding what is worth building, enforcing limits, checking the implementation and owning the result. An SDD team can also do those things; the duties are not exclusive to either name. This book teaches the reasoning behind them alongside the tools.

Even the person who coined vibe coding now draws a similar line. In a 2026 summary of one of his talks, Andrej Karpathy wrote that vibe coding is fine for prototypes (quick first versions) and personal tools, while serious teams need what he calls agentic engineering.

Safety floor

Whatever the AI writes for you, it is not finished until you have checked it yourself. The AI can test its own work, but its tests can miss things, and it often sounds just as sure when it is wrong. And if something breaks later, "the AI wrote it" is not an answer anyone will accept. The work is yours.

Three ways to get it wrong, and what two real incidents teach​

The Welcome named three mistakes. Here they are in full.

Holding AI back means using it only for small jobs and doing the important work by hand, slowly, even where AI now does it well. When about three quarters of new code at one of the world's largest software companies is generated by AI, holding it back means falling behind, however careful it feels. People usually hold back for one of three reasons: they don't know how powerful AI has become, they don't know how to use it well, or they fear it, either its mistakes or being replaced by it.

Not every kind of holding back is a mistake, though. Sometimes the law, a contract, or the kind of data involved limits where AI may be used. Patients' records at a hospital are a common example. Keeping AI out of that work is not falling behind. It is a careful engineering decision.

Trusting AI blindly means handing it decisions nobody made. I made this mistake myself. When I was a beginner, an AI deleted weeks of my work, and I spent weeks doing it all again. Two real incidents show what it can cost a company:

  • July 2025. A founder was building an app on Replit, an AI coding platform, during an explicit freeze on all changes. Its AI agent deleted the live database anyway: the real one, holding records for about 1,200 executives and 1,200 companies. It then made thousands of fake records and said the deletion could not be undone. It could, and the data was restored (reported by PCMag).
  • April 2026. At PocketOS, a small software company, an AI coding agent deleted the company's entire live database, and its backups, with a single command. It took nine seconds. The agent was Cursor, running Anthropic's Claude Opus 4.6. The company recovered only from a three-month-old backup kept somewhere else, and only after more than two days. Its customers were left with gaps in their data (reported by The Guardian).

Look at what failed in both, and it was not the code. Both teams had written rules, and nothing enforced them. At Replit, the app being built and the live app shared one database, so the agent could reach the real data. At PocketOS, the agent found a key, a kind of password, with no limits on what it could do, and the backups sat in the same place as the data, so one command destroyed both.

A rule the AI is only asked to follow is a request. A limit the system enforces is engineering. Nobody had limited the AI's blast radius: how much can break, and how far the damage reaches, if something goes wrong. That decision was never made: vibe decisioning in its plainest form. Limiting blast radius is a whole discipline of engineering, and you will learn it properly later in this book.

Remember this

Both companies survived because a backup existed somewhere. Deciding that a backup must exist, and where, is engineering too.

Adding nothing of your own means letting the AI do all the work while you only pass it along, or building things nobody needs. It can look like success, because the app works. But anyone with the same AI can do the same, and a solution to nobody's problem earns nothing.

Why you learn software engineering and agentic AI together​

When I planned the stages, there were two obvious ways to build this book. In this era, both are dangerous.

  • Software engineering first, and agentic AI later. This is how most courses are built. But it takes years to reach AI agents this way, and in that time, people who already use AI well move far ahead.
  • Agentic AI first, and software engineering later, or never. Vibe coding breaks at a bigger level, and without the foundations you can't make better decisions than the AI.

So I merged them. In this book, you learn agentic AI in parallel with the traditional foundations of software engineering, from your first course in Stage 1, and each one speeds up your learning of the other. The first Stage 1 course brings together the foundations that agent and web work share; later courses deepen agent engineering, web development and shared operations.

A language course is a tree: you learn its stem with its roots and branches​

Part of the treeWhat it isIn this book
The stemThe language you are learningPython or JavaScript, with SQL introduced when a database needs it
The rootsWhat the language stands onThe terminal (a window where you type commands), Git (which records every change you make), packages (ready-made code other people wrote), how a program runs, and how to read an error message
The branchesWhere the language is appliedBuilding backend services behind an interface, web apps, AI agents and MCP servers

You learn the three together. The usual order finishes a language first and meets its tools much later, which turns each tool into an extra rule to memorise, because the problem it solves has not arrived yet. Here, the terminal, the package and the agent appear in the lesson that needs them. Ideas that belong to more than one skill are taught once: you meet Git in the Python course, and the web course then uses it without teaching it again.

The path from here to expert, and what every chapter gives you​

The book takes you from where you are to expert level in three stages. A stage is a level of difficulty. A course inside a stage is one subject.

  • Stage 0 — Introduction to SDE. Two introductory courses for a reader starting from zero. Introduction to Software Engineering introduces programs, binary and languages, files and tools, reading Python, frontend/API/backend responsibilities, data and architecture. Introduction to SDE and Basic Terminology introduces coding agents, permissions, Code Literacy, specifications, verification and this book's engineering method. The examples show checked results on the page; no installation or AI account is required.
  • Stage 1 — Software and AI Engineering Foundations. Four sequential courses: common foundations first, then deeper agent engineering, advanced web work and shared operations. Begin with the available Course 1 lessons; a description of the curriculum does not mean every later lesson is already available.
  • Stage 2 — Advanced Solution Engineering. Advanced specialisations in software engineering, agents, AI use and web development, including DevOps and platform engineering. You use Spec-Driven Engineering for whole solutions, with deeper reliability, security, communication and business judgment. The Stage 2 overview shows the curriculum and method; its lessons are not available yet.

The suggested pace is one lesson a day. Read it from beginning to end, then try its questions. A chapter holds as many lessons as its topic needs.

The book prepares you for paid work by solving real problems. Building a café's website with AI coding agents, or a booking agent for a clinic, can each take away a real person's problem. Whether someone pays depends on the problem you choose, the people you serve and the evidence you can show; finishing a course alone does not establish it. Lessons on the fifth skill, problem solving and earning, are still being planned.

In every chapter, you will see what the AI can do for you there, and what only you can do. By the end, the three steps are simply how you work.

I research, discuss with experts, think and plan for hours every day. So the shape of these stages may change as the book grows, and every change is recorded in the changelog.

What this page cannot promise you​

A thesis worth trusting says where it could be wrong.

  • The line will keep moving. Some things AI can't do today, it will soon be able to do. When that happens, the book updates the claim and records the change, with its date, in the changelog.
  • Some numbers come from companies talking about themselves. A CEO's figure for AI-written code or images made is a claim, not an audit. The book uses such figures to show direction, not precision.
  • Spec-Driven Engineering is this book's own term. It builds on spec-driven development, which the industry does use, but it is not an established industry name yet.
  • No book can promise you a job, a client or a sale. Whether someone hires you or pays you depends on the problem, the people and the evidence you can show. This book promises the skills the evidence points to, taught as well as I can teach them, for free.

Before you go: can you do the first step yourself?​

Two small questions, and no scrolling up:

  1. What is vibe decisioning, and why can it hurt you even when the code works?
  2. Think of one real person's problem you could solve: a relative's shop, a clinic near you, a client or your class. Name one part you would ask the AI to do, and one place where you would add value the AI can't add alone.

If you could answer both, you have just done step 1.

Where to go next​

If this page made sense, you are ready for Stage 1.

If parts of it felt hard, come with me to Stage 0. Both introductory courses are ready to read. There, I start from the very basics and introduce the ideas behind this page, step by step.