The Builder’s Progression

A Trail Map for Where You Are and the Climb Ahead

Jul 23, 2026

Most people disappointed by AI are disappointed for the same reason: they cannot tell where they are standing.

Picture the associate dean who activated her campus ChatGPT license the week it arrived. She asked it to summarize a strategic plan and got back four paragraphs of grey oatmeal. She tried again with a sharper question and got slightly better oatmeal. Then she closed the tab and concluded, reasonably, that the technology had been oversold. Two doors down, a program coordinator opened the same license and did one thing differently. He pasted in last year’s assessment rubric, attached three sample student papers, and told the model to find every place where the rubric and the papers disagreed. What came back was a redraft of the rubric that closed the gaps he had been arguing about in committee for a year. That rubric now saves him six hours a week. Same tool, same institution, same month. One of them thinks AI is a parlor trick. The other thinks it is the most useful colleague he has ever worked with.

The distance between those two people has nothing to do with intelligence, budget, or technical background. It comes down to position. The coordinator happened to stand one stage higher on a progression almost nobody has drawn out loud, and from that elevation the whole terrain looked different.

When people meet AI and walk away unimpressed, they tend to reach one of two conclusions. Either the technology is hype wearing the costume of a revolution, or it is real but reserved for other people, the developers and engineers and quantitative types who supposedly speak its language. Both conclusions are wrong, and both are honest mistakes, because no one ever handed these people a map.

Solving a small, expensive problem beats solving a big, vague one every time. But when you cannot see the steps between where you stand and the solution you want, the whole effort feels vague, and vague effort is exactly the kind people abandon.

This is the map. Read it twice: once to place yourself, and once to place the campus or organization you are trying to move. The second reading is the harder one.

Thanks for reading Purposeful AI! This post is public so feel free to share it.

Why a Progression and Not a Hierarchy

Before we walk the stages, it helps to say plainly what this map measures and what it leaves alone.

It measures capacity, and capacity gets built. Raw intelligence and technical pedigree barely enter into it. What matters is a set of specific skills, some of them genuinely simple, and the nerve to use them in front of other people.

In 1980, the brothers Stuart and Hubert Dreyfus, an engineer and a philosopher, described how a person actually acquires a skill, from novice to expert. Their central observation was that the novice clings to explicit rules while the expert has absorbed those same rules so completely that they respond to a situation without ever consulting them. Skill acquisition is a slow migration from following instructions to having instincts. That is precisely what happens across these AI stages. The beginner obeys the rule “type a question, read the answer.” The advanced builder has internalized so many rules about how these systems behave that they design with them the way a carpenter reaches for a plane, without looking.

The map is also not a mandate. Different people need different things from these tools. Someone who wants a genuine thinking partner for their writing has no reason to become a programmer. Someone who wants to reclaim three hours of weekly drudgery has no reason to build an application. The goal is to reach the stage that gives you what you actually need, and to recognize it when you arrive. The final stage is a destination almost no one is obligated to reach.

Each stage also rests on the one beneath it. You do not skip ahead so much as accumulate footholds, carrying every capacity you built earlier into everything that comes after. Miss one and the gap in the trail tends to find you later, a fact that becomes painfully literal around Stage 7.

The Ten Stages

Here is the ascent, trailhead to summit. Each stage stands on the one below it.

Stage 0: The Bad Chat User

Most people begin here, and there is no shame in it. It is where anyone lands who picks up an unfamiliar tool with no instruction.

The bad chat user treats AI like a search bar or a vending machine. You put in a question, you take out an answer, and when the answer disappoints, you either retry with the same blunt phrasing or decide the machine does not work. Nothing about the exchange is deliberate. The user has heard AI called transformative, yet the thing in front of them behaves like a slightly quicker Google. The friction is real, but it comes from how the tool is being held, and the tool itself is barely being asked to work.

Stage 1: The Chat User

Something shifts. The stage-one user has learned that AI performs better when handed context, a clear instruction, and a specific request. Conversations start to feel productive. The results are often good, sometimes genuinely useful.

The ceiling is that everything still happens inside a single conversation. Each session begins from nothing. There is no system, no artifact, nothing built to outlast the chat window once it closes. The user has learned to ask well, and asking well turns out to be only base camp.

Stage 2: The Prompt Engineer

Here we cross the first real threshold. The prompt engineer discovers that the shape of the input governs the shape of the output, and begins writing prompts on purpose. They hand the model a role. They specify a format. They break a tangled request into ordered steps.

That discovery changes the relationship. The user stops being a passive recipient and becomes the designer of the exchange, arranging the conditions under which the model thinks. The black box turns into a system with dials you can turn. Once someone has felt that shift, they rarely go back to typing hopeful questions into a void.

Stage 3: The Bot Builder

Once you know that a well-built prompt reliably produces better work, the obvious next move is to stop retyping it. The bot builder recognizes that a good instruction set is worth saving.

A bot is a reusable prompt with a job: standing instructions that tell an AI what role to play and how to shape what it returns. Drop that instruction set into a Claude Project or a custom GPT and you have a tool you can hand to yourself, or a colleague, again and again. The bot builder is working as an implementer, taking a designed logic and putting it into service. This is the first stage where the output is a thing that persists after you walk away from the keyboard.

Stage 4: The File Maker

Stages three and four mark the move from conversation to artifact, though the first artifacts are humble. Nobody jumps straight to building web applications.

The file maker begins by noticing that the model can produce structured text: Markdown, CSV, clean JSON. Only after that do they graduate to HTML, which can do what plain text cannot, carrying visual layout, styling, and simple interactivity. Someone who has never written a line of code finds themselves producing web-formatted documents that look designed. It is a quiet expansion, easy to miss, and it changes the self-concept of the person doing it. They have stopped asking the machine for words and started using it to make things.

Stage 5: The Workflow Integrator

The workflow integrator wires AI into the tools they already live in, and they do it without writing code, using connective platforms like Zapier or Make to link an email trigger here and a calendar event there.

This is where AI stops being a destination you visit and becomes a component inside a larger flow of work. Imagine an incoming student question that is routed, categorized, and answered in draft form before any human touches it. The integrator is designing the environment in which the model does one specific job as part of a chain.

Stage 6: The Small Program Builder

Moving from a drag-and-drop workflow to writing actual code is the steepest single stretch of the whole climb. What bridges it is comfort with formulas, the kind advanced Excel logic teaches, and a working sense of how data is structured.

The small program builder writes code, or more honestly directs an AI to write code, to handle structured, repetitive tasks: scripts that process files, small tools that reshape data from one form into another. They have internalized the difference between a wall of unstructured text and a clean table of structured data, and they use AI to move between the two. Picture a short Python script that reads a folder of course syllabi and checks each one against a newly revised institutional policy, flagging the three that fall short before a committee ever meets. The work is unglamorous and enormously freeing.

Stage 7: The Vibe Coder (The Shadow Path)

I want to be honest about this stage, because it is where a great many capable people are quietly stuck. It sits inside the progression, yet it operates as a shortcut, and shortcuts on this map charge interest.

Vibe coding means describing an application to a coding AI, something like Cursor or Lovable, and letting the model generate the whole thing, straight from idea to working prototype with none of the intermediate capacities built along the way. For a weekend, it feels like magic.

The trouble arrives on Monday, when the application breaks or needs to change and the person running it has no idea what to do. This is where a distinction the philosopher Gilbert Ryle drew in 1949 turns out to be a lesson about software. Ryle separated knowing that from knowing how. You can know that a bicycle stays upright through balance and still have no idea how to ride one. The vibe coder holds the artifact without holding the know-how that would let them repair it. They did not build the thing they are running; they described it, and the machine conjured it into being. What they are left with is brittle, opaque, and expensive to maintain, a pile of technical debt with their own name on it. Vibe coding is a real on-ramp, as long as the builder eventually returns to lay down the Stage 6 foundation they skipped.

Stage 8: The Deliberate Prototype Programmer

The deliberate prototype programmer builds applications with real understanding underneath them. They still lean on AI heavily to generate code and hunt bugs, but they grasp the architecture of what is being assembled. They can read the code closely enough to judge whether it does what they intended, which means they can tell when the model has quietly done something else.

Here the roles of implementer and engineer genuinely blur. The builder is making real decisions about how the system is shaped, holding to principles like Zero-Trust security and disciplined environment management. Ryle’s know-how has walked back into the room, and it brings a specific kind of quiet confidence. When the application throws an error at eleven at night, the deliberate programmer does not panic and does not start over. They read the message, know which file to open, and fix the line that broke. That moment, unremarkable as it looks, is the real reward of the climb: you are standing on top of something you understand, and it holds.

Stage 9: The AI-Integrated Application Builder

Here something genuinely new appears.

Everything below this line uses AI to build things. Once built, the application itself sits still and behaves the same way every time you run it. It is finished, static, predictable.

At stage nine, the AI is making live calls from inside the running application. The software is powered by a model in real time, making decisions, generating content, classifying inputs, and routing outputs according to context it has never seen before. Picture an advising tool that reads each incoming student message as it lands, judges how urgent and how fraught it is, drafts a reply in the voice of the office, and decides on its own whether the message is safe to answer automatically or needs a human advisor’s eyes first. No one wrote a rule for the note that arrived at two in the morning. The application reasoned about it live. This is the boundary between building with AI and building things that are themselves AI. Cross it and you stop being a person who used a model to produce software. You become a person whose software thinks on its feet.

What the Map Is Really Showing You

Read the ten stages quickly and they look like a technical syllabus. Read them slowly and they describe something far older than software.

Every stage is the same human motion performed at a higher altitude. A person stops treating a capability as a black box and starts treating it as something they can shape. The bad chat user accepts whatever the vending machine drops. The prompt engineer reaches in and rearranges the mechanism. The application builder reaches all the way in and constructs a new machine that runs on its own. What changes at each stage is the person’s relationship to their own agency, far more than the technology in front of them.

This is why the Dreyfus insight matters more than any single tool on the list. The expertise those brothers described is one slow conversion: borrowed rules becoming owned instincts, and it happens only through building. You cannot read your way to Stage 6. You cannot watch a webinar into Stage 8. The capacities are built the way a muscle is built, under load, one honest attempt at a time. The Shadow Path tempts precisely because it promises the altitude without the climb, and the map’s central warning is that altitude bought that way will not hold your weight when the ground shifts.

Leading the Progression: A Framework for Campus AI Strategy

For anyone leading in higher education, reading this map for yourself is the easy half. The hard half is leading a whole campus up the climb it describes.

You cannot drop a Stage 6 solution, a custom-built application, onto a Stage 1 faculty body and expect it to hold. Change management means meeting people where their collective center of gravity actually sits, then moving it one stage at a time.

Stages 0 to 2, the Chat Phase. The era of faculty development workshops and shared prompt libraries. The work here is lowering friction and building basic fluency, so that the associate dean from a few paragraphs ago never again mistakes grey oatmeal for the ceiling of what the tool can do.
Stages 3 to 5, the Workflow Phase. The era of departmental efficiencies, where you back your staff as they build bots for admissions triage, syllabus auditing, and advising. This is where saved hours start showing up on real calendars.
Stages 6 to 9, the Systems Phase. The era of IT-secured, institution-wide AI applications. This one demands data literacy, deliberate architecture, and Zero-Trust infrastructure, and it cannot be hurried along by decree.

The Leadership Diagnostic

To turn all of this into a plan, sit with three questions.

Where is our center of gravity? Are most of your people still bad chat users, or have they begun building bots? Strategy aimed two stages above where your people actually stand is strategy that will be quietly ignored.
Are we rewarding the Shadow Path? Are we celebrating the fast, flashy deployment of vibe-coded tools without asking whether their creators understand the systems they have set loose on real student data?
What is the next stage? You do not need everyone at Stage 9. You need to move your Stage 1 users to Stage 2 and your Stage 5 team to Stage 6. The next step up is the only one that matters.

For now, the work is honest location. Find yourself on the map, and find your campus, without flattering either. The stage you are on says nothing about your worth or your ceiling. It is simply where the climb continues from. Most people never need the summit. What they need is the next step, because one stage higher puts a new small, expensive problem within reach, the kind that used to sit on the far side of the trail, unreachable from where they stood. Look down at your feet, then up one step. That step, and the problem it finally lets you solve, is the whole of the work in front of you.