How to use this course
How to get this out of the course
Who this is for
What runs through every lesson
Exercise 1
What it costs, and where it stops
If you’re not the junior
Where to start
What the canon means here
What this course doesn’t do
The situation index
Quiz 1
3 attempts allowed
Lesson 1: The job you were hired into changed while you were in it
Exercise 2
The toll nobody called training
Exercise 3
The toll is optional now
Exercise 4
The uncomfortable version
Exercise 5
The arithmetic that makes this affordable
Exercise 6
What didn’t change
Exercise 7
The best tutor a junior has ever had
Exercise 8
Exercise 9
Quiz 2
3 attempts allowed
Lesson 2: Comprehension is the job, and it binds everyone
Exercise 10
Explaining isn’t summarizing the diff back
Exercise 11
The four claims
Exercise 12
The four levels, and the jump everybody skips
Exercise 13
It binds everyone
Exercise 14
CHARTER-GAP
Exercise 15
Quiz 3
3 attempts allowed
Lesson 3: What the team owes you, and how to tell in week one
Exercise 16
The charter is the best onboarding you’ve had
Exercise 17
When it can’t say why, the gap is theirs
Exercise 18
A red pipeline is the cheapest lesson in the building
Exercise 19
Three things to watch for, quietly
Exercise 20
When there’s none of it
Exercise 21
Quiz 4
3 attempts allowed
Lesson 4: Reading open source with an agent
Exercise 22
Picking the project
Exercise 23
The loop
Exercise 24
Reading for the canon, not for the code
Keeping the log
Exercise 25
What reading without stakes doesn’t build
Exercise 26
Quiz 5
3 attempts allowed
Lesson 5: The tools churn and the canon does not
Exercise 27
What the canon is
Exercise 28
The prediction that went the wrong way
Exercise 29
Amplification, with the numbers
Exercise 30
The compounding case
Exercise 31
What a vocabulary can’t do
Exercise 32
Quiz 6
3 attempts allowed
Lesson 6: The canon, indexed by situation
The card
Exercise 33
What each row is actually for
Exercise 34
Thirty pages, not four hundred
Reading it with the agent
Exercise 35
Quiz 7
3 attempts allowed
Lesson 7: Cold codebase, the first week on a system you cannot name
Exercise 36
The trace: one concept, entry point to last write
Exercise 37
The map: one page, by hand
Exercise 38
The question budget: twenty, and three kinds of answer
Exercise 39
The claim, and the memory test
Exercise 40
Three ways the week evaporates
Exercise 41
Exercise 42
Quiz 8
3 attempts allowed
Lesson 8: Seams, boundaries, and where a change lands
Exercise 43
Finding a seam
Exercise 44
The boundary that should exist and doesn’t
Exercise 45
Which way the arrows point
Exercise 46
Ports and adapters, used as a reading tool
Exercise 47
What the agent is good at here, and what it will get wrong
Exercise 48
Quiz 9
3 attempts allowed
Lesson 9: Names and boring code
Exercise 49
Deep or shallow, judged on a diff
Exercise 50
Simple isn’t easy, and boring wins under an agent
Exercise 51
The name that describes the implementation
Exercise 52
The rename move
Exercise 53
Pattern vocabulary is compression
Exercise 54
Quiz 10
3 attempts allowed
Lesson 10: Naming the failure shape
Exercise 55
The four moves
Exercise 56
The seven shapes
Policy inversion
Silent representation change
A test that can’t fail
Swallowed error
Scope creep
Invariant drift
Imitation of the wrong pattern
Exercise 57
Why the suite doesn’t save you
Exercise 58
Why seven and not seventy
Which of these stays yours
Exercise 59
The honest limit
Exercise 60
Writing your eighth
Exercise 61
Quiz 11
3 attempts allowed
Lesson 11: Predict, prove, classify
The prediction line
Exercise 62
The verdict goes down before the conversation
Exercise 63
Proof, and the line you’ll want to blur
Exercise 64
Classify it, because the class is what travels
Exercise 65
The rep sheet
Exercise 66
Running the rep alone
Exercise 67
Reading your own twelve weeks
Exercise 68
Saying you don’t know, in a way that counts
Exercise 69
Quiz 12
3 attempts allowed
Lesson 12: The test that proves nothing
Exercise 70
Guides and sensors
Exercise 71
Break it on purpose
Exercise 72
What the test is allowed to know
Exercise 73
The falsifier before the fix
Exercise 74
Four pillars, on Imani’s diff
Exercise 75
Flaky is a design signal, and coverage is a floor detector
Exercise 76
Quiz 13
3 attempts allowed
Lesson 13: The hunt
Exercise 77
Bound it, then let the arithmetic work
Exercise 78
The five lies
Exercise 79
When there’s no clean test
Exercise 80
The location isn’t the finding
Exercise 81
Why the drill closes the agent and the incident doesn’t
Exercise 82
Exercise 83
Quiz 14
3 attempts allowed
Lesson 14: Ask what the rule is, not what the algorithm is
Exercise 84
Why the model can’t have this
Exercise 85
Reaching for the rule before the algorithm
Exercise 86
When the code’s word and the room’s word drift apart
Exercise 87
Finding the rule when nothing in the repository answers
Exercise 88
Writing it down so the next person doesn’t have to ask
Exercise 89
The gap you record in month two
Exercise 90
Assuming isn’t the problem
Exercise 91
Quiz 15
3 attempts allowed
Lesson 15: Characterize before you change
Exercise 92
Pinning is not endorsing
Exercise 93
Let the agent write them, then check the one thing
Exercise 94
When you can’t see the behavior
Exercise 95
The agent’s favorite mistake here
Exercise 96
Read Feathers, all of it
Exercise 97
Quiz 16
3 attempts allowed
Lesson 16: Never in the same commit
Exercise 98
The rule, and why it’s not fussiness
Exercise 99
Why the agent mixes them
Exercise 100
Read the ticket, then the diff
Exercise 101
Splitting a mixed diff after the fact
Exercise 102
What the split buys
Exercise 103
Exercise 104
Quiz 17
3 attempts allowed
Lesson 17: Small, reversible, and still releasable
Exercise 105
The cheapest scope test there is
Exercise 106
Reversible is the property to optimize
Exercise 107
When your change stops being ordinary
Exercise 108
Every commit releasable, when you didn’t type the commit
Exercise 109
Exercise 110
Quiz 18
3 attempts allowed
Lesson 18: Legacy, migrations, and the codebase with two right answers
Exercise 111
Pin, check, then hand over
Exercise 112
Two right answers, and you’re told to follow the minority one
Exercise 113
The agent gets more confident as the migration goes worse
Exercise 114
Codemod or decision
Exercise 115
When the migration lands on you
Exercise 116
Quiz 19
3 attempts allowed
Lesson 19: Driving
Exercise 117
The five questions
Exercise 118
Pacing, not skill levels
Exercise 119
Choosing the pace for the work, not for your ego
Exercise 120
Context is a budget, not a vault
Exercise 121
Stop and restart
Exercise 122
Prompts that carry the falsifier
Exercise 123
The thing you’re better at than your senior
Exercise 124
Quiz 20
3 attempts allowed
Lesson 20: The capability ladder, from your side
Four rungs, from open to hidden
Exercise 125
Asking for a command
Exercise 126
The cheapest rung that holds
Exercise 127
The description is a contract
Exercise 128
Every tool is a capability grant
Exercise 129
Quiz 21
3 attempts allowed
Lesson 21: Your first charter contribution
Exercise 130
Feedforward and feedback
Exercise 131
The third surface, which is the code you already have
Exercise 132
Choosing the altitude
Exercise 133
Writing the rule from an incident
Exercise 134
Deleting a rule
Exercise 135
Your confusion is the team’s missing onboarding
Exercise 136
Holding the rule when somebody finds it inconvenient
Exercise 137
Quiz 22
3 attempts allowed
Lesson 22: What you are the last check on
Exercise 138
The five rungs, and the artifact for each
Exercise 139
Reading your own rung honestly
Exercise 140
What each rung asks you to get comfortable with
Exercise 141
Why the order holds, and what to do when your job blocks a rung
The rung isn’t the permission
Exercise 142
When your team has no ladder
Exercise 143
One rung at a time
Exercise 144
Quiz 23
3 attempts allowed
Lesson 23: Keep the evidence as you go
Exercise 145
Six classes, and what each one argues for
Exercise 146
The rejection log
Exercise 147
The cost had you been wrong
Exercise 148
Put the failures near the top
Exercise 149
The strongest version isn’t a private file
Exercise 150
Reconstructing a year you didn’t log
Exercise 151
Two ways this turns into theater
Exercise 152
Exercise 153
Quiz 24
3 attempts allowed
Lesson 24: Three years, and the next thing that changes
Exercise 154
What the first three years are for
Exercise 155
The one move
What in this course expires
Exercise 156
What doesn’t
From the other chair
Exercise 157
The second decade
Quiz 25
3 attempts allowed
Lesson 25: The interview has to change
Start with the strongest argument against hiring at all
Exercise 158
The signal that broke
Exercise 159
What the job is now
Exercise 160
What to run instead
Exercise 161
Five things to stop asking
Exercise 162
Five things worth more than they used to be
Exercise 163
The part the interview can’t do
Exercise 164
The other half, which is cheaper than the interview
Exercise 165
One change, if you only make one
Quiz 26
3 attempts allowed
Appendix: twelve weeks
The four standing habits
Exercise 166
The twelve weeks
The nine situational moves
Exercise 167
If you have no job
After twelve weeks
Quiz 27
3 attempts allowed
Sources
The card
Cited elsewhere in this course
Claims in this course with nothing behind them but my own use
The Last Check (The Course)
A Junior Engineer's Field Guide to Working with Agents
Your agent writes the migration faster than you would, so most of the code you answer for this year is code you read. What piles up is comprehension debt: code you are accountable for and cannot explain. Twenty-five lessons, one exercise each, teach what transfers to the next model, the next codebase and the next job: what you are the last check on.
Minimum price
$129
$179
You pay
Author earns
About
About the Course
The job you were hired into changed while you were in it. Your agent writes the migration, the validation and the glue faster than you would, at any hour. So most of the code you are accountable for this year is code you read rather than code you wrote. That is a different skill from the one you were hired on, and it fails in a different way. It also removes the thing that used to build judgment for free. You can now ship a correct change to a system you could not draw on a napkin, and nothing in your week raises a hand. This course has a name for what accumulates: comprehension debt, meaning code you are accountable for and cannot explain. What is new is not that it exists. It is how fast you can take it on.
This is a field guide, indexed by the situation in front of you rather than by syllabus. Twenty-five lessons, and every one written to you ends in an exercise small enough for a Wednesday afternoon and never contingent on a manager saying yes. It rests on a small canon that predates the agent and will outlast it: Parnas on what a module should hide, Feathers on changing code that nothing tests, Evans on the word the business uses for a thing. The test for anything in here is whether the skill transfers to the next model, the next codebase and the next job. You do not need a job to use it. Most lessons also carry two short blocks, one for the engineer who already runs the move and one for whoever is mentoring them, and the last lesson is written for the person who runs hiring.
The cost, stated up front: about three and a half hours a week if you run all of it. There is a smaller version that costs a minute a change, and it is the part I would protect if everything else went. No course hands anybody judgment. What this one gives you is the vocabulary, the exercises and the order to run them in. The practice has to be yours, on code somebody is actually going to run. Seniority here is not tenure and it is not a title. It is what you are the last check on, and it is what you keep when the tools change again.
Instructor
About the Instructor
Ian Johnson is a staff engineer at Parento, where he runs the engineering team's adoption of AI coding agents and the harness work that keeps that adoption from breaking in production. He owns and operates Fulcorum, a video learning platform that teaches agentic engineering. He wrote five open-source projects that support reliable AI output: Keystone, Open Refinery, Sigma, Ghola, and Gauge. He has been writing about this work at blog.tacoda.dev since 2024 via Medium and the DEV Community. He lives outside Austin with his family.
Material
Course Material
The Leanpub 60 Day 100% Happiness Guarantee
Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.
See full terms...
Earn $8 on a $10 Purchase, and $16 on a $20 Purchase
We pay 80% royalties on purchases of $7.99 or more, and 80% royalties minus a 50 cent flat fee on purchases between $0.99 and $7.98. You earn $8 on a $10 sale, and $16 on a $20 sale. So, if we sell 5000 non-refunded copies of your book for $20, you'll earn $80,000.
(Yes, some authors have already earned much more than that on Leanpub.)
Learn more about writing on Leanpub
Free Updates. DRM Free.
If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).
Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.
Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.
Learn more about Leanpub's ebook formats and where to read them
Write and Publish on Leanpub
You can use Leanpub to easily write, publish and sell in-progress and completed ebooks and online courses!
Leanpub is a powerful platform for serious authors, combining a simple, elegant writing and publishing workflow with a store focused on selling in-progress ebooks.
Leanpub is a magical typewriter for authors: just write in plain text, and to publish your ebook, just click a button. (Or, if you are producing your ebook your own way, you can even upload your own PDF and/or EPUB files and then publish with one click!) It really is that easy.