Joanah Fermin

Tutorials / Disciplined AI-Assisted Development · Lesson 6 of 14

On this page

    Overview of the Process

    Lessons 01 to 05 were about how an AI behaves and how to talk to it. This lesson is the map for the rest of the course: the whole process on one page. There is very little to read, because each part gets its own lesson later.

    Our goal: see why the same AI can give two developers very different days, and see the seven steps and two rules that the rest of the course teaches.

    Here is the route:

    1. Two developers, one AI.
    2. What the second developer did that you do not see.
    3. The seven steps.
    4. The two rules.
    5. Who steers.
    6. The example project used from here on.
    7. Why this works: an AI is helped by what helps a person.

    We leave out the detail of every step. Each has its own lesson, starting with lesson 07.

    Two developers, one AI

    Meet two developers, Alex and Sam. They use the same AI, and they work through the same list of small features for an online bookshop's back-office tool, such as adding a book. They are made up, to show a pattern, and the numbers in the pictures are not measurements.

    Alex opens the AI and starts typing. The AI does not know the project, so Alex explains it. The result is close but not right, so Alex explains more. Parts get redone, then redone again. Alex works hard all day, delivers one feature, and ends up tired and frustrated.

    Sam has a quiet day and delivers five features. The prompts are short and the first attempt is right. Four need no fixes, and the fifth needs one tiny one.

    One working day with the same AI startlunchend of day Alex explain correct redo 1 feature, so many corrections. Tired. Sam ✓ ✓ ✓ ✓ ✓ free time 5 features: four clean, one tiny fix. Calm. prompt correct redo done, checked An illustration, not a measurement: one day, a few weeks into the project.

    Alex is not lazy or unskilled. The effort is going to the wrong place. The next section shows where Sam's went.

    What Sam did that you do not see

    Sam did not use a better AI, and is not smarter than Alex. Sam did the thinking earlier, and wrote it down. So the prompt is short, because the context lives in files the AI reads first.

    Where the context lives Alex Our shop sells books... We use C# and a small database, and we like... Do not use abbreviations... Add a book, with an ISBN, but not... ... Everything, typed again in every session. Sam Build task 02. the AI reads these first: README: decisions, habits the write-up of the feature the task list The context lives in files. The same information, in two places.

    The effort did not disappear. It moved to the front, before any code. Writing things down takes time, so Sam's first feature may not be faster than Alex's. But the files are reused for every later feature and every new session, which is why the days get calmer. This is the handbook from lesson 02: a new hire every time, and the handbook holds the memory.

    The seven steps

    This is the map. The rest of the course fleshes out each step.

    Before any code is written

    1

    Explore

    Discuss the problem and goals with AI, tapping its broad technical knowledge to explore the options, then decide together.

    2

    Document

    Write down the project decisions, what the team likes and doesn't, and a list of what to build.

    3

    Specify

    Write each feature out in detail before any coding, a batch at a time.

    Then the code

    4

    Build

    AI codes one feature at a time, working from its write-up.

    5

    Test and AI review

    AI reviews the code and writes unit tests.

    6

    Human review

    Every change is read and approved by a person before it goes in.

    7

    Refine

    Tick off the feature and move to the next one.

    Steps 1 to 3 are conversation and writing, so they work in a plain chat. In steps 4 to 7 the AI gets hands (lesson 04), which is why they come after the thinking.

    The two rules

    Two rules sit over all seven steps. They are the discipline in this course's title.

    The two rules Rule 1: docs first The plan changes The docs change first Then the code changes So the docs never lie. Rule 2: lessons go back Something goes well or badly It is written into the docs The next result is better So the AI learns the team's way. Both rules keep the docs true and useful.

    Why docs first? An AI reads the docs. If the code changes first, the docs now describe something that no longer exists, and the next session is steered wrongly (lesson 02, "walls, not a guarantee"). Lesson 08 introduces rule 1 and lesson 14 uses it. Rule 2 is the handbook idea again: each lesson learned makes the next result better, judged by your own team's standard.

    You steer

    The AI brings knowledge and speed. It does not decide. At every step it drafts, and you read, decide and approve. When the draft is not right, you say what to change, and it tries again (lesson 05).

    The AI drafts, you decide The AIdrafts Youread and decide Written downin the docs not right? say what to change

    The process is general. It works with any capable language model and any tool that lets you talk to one. The examples use Claude Code, so there is something concrete to type and see. Steps 1 to 3 need no tool beyond a chat window. Claude Code arrives in lesson 10.

    The example we use

    From here, every example is one small project: a back-office tool for an online bookshop, the same shop as in the API course. Staff use it to add books without typing about 2,000 of them by hand, and to find them again.

    The bookshop back-office tool Bookshop back office Login Add books Search and list Add a book by hand a pattern feature: a form, a save, a list Scan a barcode to add the tricky feature: it depends on an online lookup Two features, one small and one tricky, to see the process fit both.

    The code is C#, and you do not need to read it. The lessons show the documents and the conversations, not the whole program.

    Why this works

    Look at what Sam did: wrote decisions down, split the work into clear tasks, read every change, and kept what was learned. That is not special to AI. It is what good teams already do, because people also guess when they are not told, forget what was not written, and make mistakes that a second pair of eyes catches.

    An AI is now much the same on this point. It does better work when it is given good guidance, clear tasks and a check on the result, and it does worse work, faster, without them. So the same engineering practice that makes a team trustworthy also makes the AI's results better.

    Good practice helps a person and an AI A person Good practice Decisions written down Clear tasks Every change reviewed Lessons kept An AI better better The same practice helps both.

    💡 A simplification: inside, an AI is not a person (lesson 01). What matches is what helps it: clear guidance, small clear tasks, a second look. Keep the idea, not the comparison.

    Recap

    • The same AI gives two developers very different days. The difference is practice, not talent or the model.
    • The second developer did the thinking earlier and wrote it down, so the prompts are short and the context lives in files. The effort moved to the front. It was not removed.
    • The process has seven steps: Explore, Document, Specify (before any code), then Build, Test and AI review, Human review, Refine.
    • Rule 1: any change of plan goes into the docs first, then the code.
    • Rule 2: every lesson learned goes back into the docs, so later results are better.
    • You steer. The AI drafts, and you decide and approve.
    • An AI is helped by what helps a person: good guidance, clear tasks, a second look. Good practice makes better results.

    Questions to think about

    The answers are left out on purpose. Try them in your own words first.

    1. Why were Sam's prompts short and Alex's long?
    2. Where did Sam's effort go, and why does it pay back?
    3. What are the two groups of the seven steps?
    4. In your own words, what does rule 1 protect against?
    5. Why does good engineering practice help an AI, as it helps a person?

    Next lesson: step 1, Explore. How to talk a problem through with an AI and decide what to build.

    ← Common Ways of Getting Better AI ResultsExplore: Talk It Through Before You Build →