Leanpub Header

Skip to main content
Go to Leanpub.com

The Last Check

A Junior Engineer's Field Guide to Working with Agents

The Last Check
This book is 95% completeLast updated on 2026-10-05
+70% in the last 30 days
Ian Johnson

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 chapters, 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

$10.00

$20.00

You pay

Author earns

$

Also available for 1 book credit with a Reader Membership

PDF
EPUB
WEB
APP
About

About

About the Book

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 book 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 chapters, 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 chapters also carry two short blocks, one for the engineer who already runs the move and one for whoever is mentoring them, and the last chapter 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 book 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.

Share this book

Feedback

Contact the author

Author

About the Author

Ian Johnson

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.

Launch

Launch Video

Subscribe on YouTube

Clips

Clips

View all clips →

Contents

Table of Contents

How to use this book

  1. How to get this out of the book
  2. Who this is for
  3. What runs through every chapter
  4. What it costs, and where it stops
  5. If you are not the junior
  6. Where to start
  7. What the canon means here
  8. What this book does not do
  9. The situation index

Chapter 1: The job you were hired into changed while you were in it

  1. The toll nobody called training
  2. The toll is optional now
  3. The uncomfortable version
  4. The arithmetic that makes this affordable
  5. What did not change
  6. The best tutor a junior has ever had

Chapter 2: Comprehension is the job, and it binds everyone

  1. Explaining is not summarizing the diff back
  2. The four claims
  3. The four levels, and the jump everybody skips
  4. It binds everyone
  5. CHARTER-GAP

Chapter 3: What the team owes you, and how to tell in week one

  1. The charter is the best onboarding you have had
  2. When it cannot say why, the gap is theirs
  3. A red pipeline is the cheapest lesson in the building
  4. Three things to watch for, quietly
  5. When there is none of it

Chapter 4: Reading open source with an agent

  1. Picking the project
  2. The loop
  3. Reading for the canon, not for the code
  4. Keeping the log
  5. What reading without stakes does not build

Chapter 5: The tools churn and the canon does not

  1. What the canon is
  2. The prediction that went the wrong way
  3. Amplification, with the numbers
  4. The compounding case
  5. What a vocabulary cannot do

Chapter 6: The canon, indexed by situation

  1. The card
  2. What each row is actually for
  3. Thirty pages, not four hundred
  4. Reading it with the agent

Chapter 7: Cold codebase, the first week on a system you cannot name

  1. The trace: one concept, entry point to last write
  2. The map: one page, by hand
  3. The question budget: twenty, and three kinds of answer
  4. The claim, and the memory test
  5. Three ways the week evaporates

Chapter 8: Seams, boundaries, and where a change lands

  1. Finding a seam
  2. The boundary that should exist and does not
  3. Which way the arrows point
  4. Ports and adapters, used as a reading tool
  5. What the agent is good at here, and what it will get wrong

Chapter 9: Names and boring code

  1. Deep or shallow, judged on a diff
  2. Simple is not easy, and boring wins under an agent
  3. The name that describes the implementation
  4. The rename move
  5. Pattern vocabulary is compression

Chapter 10: Naming the failure shape

  1. The four moves
  2. The seven shapes
  3. Why the suite does not save you
  4. Why seven and not seventy
  5. Which of these stays yours
  6. The honest limit
  7. Writing your eighth

Chapter 11: Predict, prove, classify

  1. The prediction line
  2. The verdict goes down before the conversation
  3. Proof, and the line you will want to blur
  4. Classify it, because the class is what travels
  5. The rep sheet
  6. Running the rep alone
  7. Reading your own twelve weeks
  8. Saying you do not know, in a way that counts

Chapter 12: The test that proves nothing

  1. Guides and sensors
  2. Break it on purpose
  3. What the test is allowed to know
  4. The falsifier before the fix
  5. Four pillars, on Imani’s diff
  6. Flaky is a design signal, and coverage is a floor detector

Chapter 13: The hunt

  1. Bound it, then let the arithmetic work
  2. The five lies
  3. When there is no clean test
  4. The location is not the finding
  5. Why the drill closes the agent and the incident does not

Chapter 14: Ask what the rule is, not what the algorithm is

  1. Why the model cannot have this
  2. Reaching for the rule before the algorithm
  3. When the code’s word and the room’s word drift apart
  4. Finding the rule when nothing in the repository answers
  5. Writing it down so the next person does not have to ask
  6. The gap you record in month two
  7. Assuming is not the problem

Chapter 15: Characterize before you change

  1. Pinning is not endorsing
  2. Let the agent write them, then check the one thing
  3. When you cannot see the behavior
  4. The agent’s favorite mistake here
  5. Read Feathers, all of it

Chapter 16: Never in the same commit

  1. The rule, and why it is not fussiness
  2. Why the agent mixes them
  3. Read the ticket, then the diff
  4. Splitting a mixed diff after the fact
  5. What the split buys

Chapter 17: Small, reversible, and still releasable

  1. The cheapest scope test there is
  2. Reversible is the property to optimize
  3. When your change stops being ordinary
  4. Every commit releasable, when you did not type the commit

Chapter 18: Legacy, migrations, and the codebase with two right answers

  1. Pin, check, then hand over
  2. Two right answers, and you are told to follow the minority one
  3. The agent gets more confident as the migration goes worse
  4. Codemod or decision
  5. When the migration lands on you

Chapter 19: Driving

  1. The five questions
  2. Pacing, not skill levels
  3. Choosing the pace for the work, not for your ego
  4. Context is a budget, not a vault
  5. Stop and restart
  6. Prompts that carry the falsifier
  7. The thing you are better at than your senior

Chapter 20: The capability ladder, from your side

  1. Four rungs, from open to hidden
  2. Asking for a command
  3. The cheapest rung that holds
  4. The description is a contract
  5. Every tool is a capability grant

Chapter 21: Your first charter contribution

  1. Feedforward and feedback
  2. The third surface, which is the code you already have
  3. Choosing the altitude
  4. Writing the rule from an incident
  5. Deleting a rule
  6. Your confusion is the team’s missing onboarding
  7. Holding the rule when somebody finds it inconvenient

Chapter 22: What you are the last check on

  1. The five rungs, and the artifact for each
  2. Reading your own rung honestly
  3. What each rung asks you to get comfortable with
  4. Why the order holds, and what to do when your job blocks a rung
  5. When your team has no ladder
  6. One rung at a time

Chapter 23: Keep the evidence as you go

  1. Six classes, and what each one argues for
  2. The rejection log
  3. The cost had you been wrong
  4. Put the failures near the top
  5. The strongest version is not a private file
  6. Reconstructing a year you did not log
  7. Two ways this turns into theater

Chapter 24: Three years, and the next thing that changes

  1. What the first three years are for
  2. The one move
  3. What in this book expires
  4. What does not
  5. From the other chair
  6. The second decade

Chapter 25: The interview has to change

  1. Start with the strongest argument against hiring at all
  2. The signal that broke
  3. What the job is now
  4. What to run instead
  5. Five things to stop asking
  6. Five things worth more than they used to be
  7. The part the interview cannot do
  8. The other half, which is cheaper than the interview
  9. One change, if you only make one

Appendix: twelve weeks

  1. The four standing habits
  2. The twelve weeks
  3. The nine situational moves
  4. If you have no job
  5. After twelve weeks

Sources

  1. The card
  2. Cited elsewhere in this book
  3. Claims in this book with nothing behind them but my own use

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.

Learn more about writing on Leanpub