field guide
The Accountability Field Guide
Eight gates for the loop on your own follow-through: what to commit to, facing what you actually did, and the deferral engine that catches the task you keep avoiding. One honest story, gate by gate.
How to read this guide
The tools that remind you, track you, and nudge you are commodities, and the market is drowning in them. This guide is not about them. It is about the eight points where a day of intended work either turns into shipped work or quietly leaks away, what you are actually deciding at each, and how to tell when you are lying to yourself. Work these gates well and a plain text file holds you accountable better than any app. Work them badly and the slickest habit tracker on your phone just gives you a prettier record of the thing you keep not doing.
There's a reason the gates fall where they do. Each one marks a place where an agent, or an app, is weak. It can remind you what you said, but it can't want the outcome for you. It can count your deferrals, but it can't decide the task is worth killing. It can show you a streak, but it can't tell you the streak is theater. The gates are a map of exactly the decisions no tool can make on your behalf. Where the tool is strong you let it run, and where it's blind you stop and decide. That is the whole logic of which points made the list, and it's why the list is about honesty and not features.
You do not need to already be disciplined to use this. That's the point. The system is built for the tired, interrupted, over-committed version of you, because that's the version that shows up most days. Maybe you set goals and never review them. Maybe you're honest at night but never plan the morning. Maybe you avoid the avoidance gate hardest of all. Each gate below tells you which muscle it needs, what a good decision looks like even when that muscle is the one you're weakest at, and how to put the system to work covering for you while you build it. I run this on myself, and my weak side is right there in the examples.
The one thing the framework can't do is care for you. It gets you to a follow-through you couldn't sustain on willpower alone, but only if you treat each gate as something to answer honestly, not something to rubber-stamp. Answer the reckoning gate truthfully and you level up. Answer it with a comfortable story and you just get a well-documented record of your own avoidance.
A note on the examples. Every gate is illustrated with the same story: me, building LeadSurface and writing in the margins of a full life, using this exact system to stay honest about whether I actually did the work. One real story carried the whole way through shows you how the gates feel in sequence, including the uncomfortable part where the system I built to keep me shipping became, for a while, the thing I did instead of shipping. That's a more useful picture than a scatter of tidy wins.
Each gate below uses the same template:
- The gate — the one question, in plain language.
- Mode — Commit (deciding what deserves you), Reckon (facing what you did), or Pattern (reading the trend).
- When you're at it — how to recognize the day has reached this point.
- What the loop hands you — what the system produces or shows here.
- The decision — what you are actually on the hook for.
- What good judgment looks like — the heuristics.
- If this is your weak spot — how to work the gate anyway when it's the one you skip.
- Failure modes — what rubber-stamping this gate costs you later.
- Example — a real case from running this on myself.
The model in one page
You keep one thing and hand off everything else. You keep the wanting, the honest read on whether a goal is worth your scarce attention and whether you actually moved it. The loop keeps the memory and the counting, because that is exactly what a tired, interrupted person loses first. You forget what you committed to this morning, you lose the thread between sessions, and you never notice the task you've quietly dodged for three weeks. The loop notices.
Between your wanting and the loop's memory sit the gates. Some are commitment calls, some are honesty calls, some are pattern calls. The list, in order:
- What am I trying to move? · 1. What's the one thing today? · 2. Did I capture what I did? · 3. Did I do what I said? · 4. Am I avoiding this? · 5. What's tomorrow? · 6. What patterns emerged? · ∞. How much of this loop does today even deserve?
The last one is the master gate. You do not run the full ceremony every day. Gate ∞ is the one you always run, and it decides how much of the rest you need. A day with one good hour earns a one-line log and nothing more. A Sunday review earns the whole weekly pass. Deciding how much loop a given day earns is itself a judgment call, and getting it wrong in either direction, full ritual on a dead day or no reckoning on a week that got away from you, is its own failure.
Gate 0 — What am I trying to move?
The gate. Before any daily loop, what are the few goals this whole system is measuring against, and does each one earn its slot?
Mode. Commit.
When you're at it. Starting the system, or at a natural reset, a new quarter, a finished project, a week where nothing felt aligned. Not every day. This is the standing context every other gate inherits.
What the loop hands you. Nothing yet, and that's the trap. Setting goals feels like productivity, so the pull is to list ten of them and feel organized. The system won't stop you. It will faithfully track your follow-through against a goal that never deserved a slot.
The decision. Name the small set of outcomes worth your scarce attention, and be willing to leave a tempting goal off the list. Every goal you keep is attention you're taking from the others.
What good judgment looks like. The goal is an outcome, not an activity. "Ship LeadSurface improvements customers notice" is an outcome. "Learn four video tools" is an activity that might serve one. You write down the avoidance patterns you already know about yourself next to the goals, because naming them is what lets the later gates catch them. You keep the list short enough that "the one thing today" is a real choice, not a lottery.
If this is your weak spot. No instinct for what matters most? Force a ranking. Ask the agent to make you sort your goals against a single question, what happens if this one slips a month, and watch which ones you actually flinch at. The ones you don't flinch at probably don't earn a slot. Over time you'll feel the difference between a goal and a nice idea before you write it down.
Failure modes. Ten goals, so every day's focus is arbitrary. Goals stated as activities, so you can be busy all week and move nothing. Never writing down your known avoidance patterns, so the system can't catch you repeating them.
Example. My goals list is short on purpose, and the honest work of Gate 0 is the pruning. LeadSurface getting better every week earns a slot because the outcome is real, people paying or not paying. Writing in the margins earns one because it's the top of my funnel. Then there's the pile that tempts me every quarter: learn a new stack, build a golf-content brand, master video editing, rebuild the tooling. Each is fun and each fails the honest Gate 0 question, is this an outcome or is it me reaching for something new because the current thing is hard. Next to the goals I wrote down the patterns I know I fall into, infrastructure over output and starting new projects before finishing current ones, because those exact lines are what Gate 4 checks against later. The list isn't aspirational. It's the small set of things I'll let the rest of the loop hold me to.
Gate 1 — What's the one thing today?
The gate. Of everything open, what is the single most important thing to move today, and does it actually serve a goal?
Mode. Commit.
When you're at it. The start of the working day, or the start of the window you've got. Before you open the editor, the inbox, or the thing that's easiest to reach for.
What the loop hands you. The morning ritual surfaces yesterday's carryovers and anything you deferred, then asks for one primary focus and at most two secondary. It shows you what's still open. It will not choose for you, and it will let you pick the comfortable thing.
The decision. Name the one thing, and make it the thing that moves a goal, not the thing that's easy to start. One, not five. Five priorities is zero priorities.
What good judgment looks like. The one thing is chosen against a goal from Gate 0, not against your mood. You pick the task that's important and slightly uncomfortable over the task that's satisfying and safe. You accept that two secondaries is the ceiling, because a day in the margins fits about one real thing and a couple of small ones, and pretending otherwise is how everything slips.
If this is your weak spot. Always drawn to the easy visible task? Make the system name the alternative. Have it put your comfortable pick next to the one thing that actually moves a goal, and ask which one you'll regret skipping by Friday. On a fragmented day, the tie-breaker is simple: pick the thing that, if you only did one thing all day, would still count as a good day.
Failure modes. A focus list of five, so nothing is actually the priority. Choosing the satisfying task, the infra tweak, the refactor, over the one that moves a goal. Skipping the morning gate entirely and letting the day choose for you, which it will, badly.
Example. My reliable failure here is reaching for the infrastructure. On a morning with one open hour, the tempting focus is "improve the classify queue" or "clean up the deploy," because that work is concrete, satisfying, and entirely mine. The one thing that actually moves LeadSurface is usually the opposite: talk to a customer, ship the fix they asked for, write the post. The morning gate is where I catch the swap. It makes me write the primary focus down against a goal, and the moment I write "refactor the queue" I can see it isn't serving the goal of customers noticing the product get better this week. So the queue drops to a secondary or off the list, and the customer conversation becomes the one thing. Naming it is what stops the easy work from eating the day.
Gate 2 — Did I capture what I did?
The gate. Did the work, the decision, and the stray good idea actually get written down, or did they evaporate?
Mode. Reckon.
When you're at it. Throughout the day, at every natural break. The end of a session, the walk, the moment before you context-switch to the family or the day job.
What the loop hands you. A session log that takes one line to append. That's the whole tool. Its power is entirely in whether you use it, and the friction it's fighting is that the thought always feels like it'll still be there later.
The decision. Capture it now, in one line, before it's gone. Not a polished journal entry. A timestamp and what happened.
What good judgment looks like. You log the thing at the moment it happens, because on the margins the idea that arrives at a red light is gone by the time you're back at the keyboard. You capture decisions and their reasons, not just tasks done, because the reason is what you can't reconstruct in three days. You keep it cheap enough that logging never feels like a chore worth skipping.
If this is your weak spot. Forget to log? Attach it to something you already do. Log when you close the laptop, log when you take the walk, log when you switch contexts. Make the agent do the writing, you just say the sentence. The bar is one line. A day with three one-line entries beats a day with a perfect entry you meant to write and didn't.
Failure modes. Doing real work and logging nothing, so the reckoning gate at night has no idea what happened and neither do you. Saving it all for one big end-of-day entry that you're too tired to write. Losing the idea, the fix, the decision, because you trusted your memory in a life that doesn't leave room for it.
Example. Half of building in the margins is catching the thought before it drifts off. A fix for a nagging LeadSurface bug, the right way to word an onboarding email, the reason I chose Postgres over the markdown files, they all arrive at the worst possible moments, in the shower, at a red light, halfway through a meeting I can't step out of. If there's nowhere to put them, they're gone by the forty-minute window at night when I could actually use them. The log is that nowhere-to-put-them problem solved. I even capture the walk, one line, because the streak is a goal too and the reckoning gate can only count what got written down. The discipline that doesn't survive interruption isn't the coding. It's the capture, and the log is how I externalize it.
Gate 3 — Did I do what I said?
The gate. The morning named the one thing. Did it actually happen, or did the day fill up with everything else?
Mode. Reckon.
When you're at it. The end of the day. The uncomfortable checkpoint most systems skip, which is exactly why they don't work.
What the loop hands you. The end-of-day pass diffs this morning's focus against the day's log. For every focus item the log doesn't show, it increments a deferral counter. It hands you the honest count, whether you want it or not.
The decision. Face the gap truthfully. Did the one thing move, and if not, why not, and does that count as a deferral you own. The whole system's integrity lives at this gate. Lie here and everything downstream is fiction.
What good judgment looks like. You mark the miss as a miss instead of quietly editing this morning's goal to match what you happened to do. You let the deferral increment, because the count is the signal. You separate "I chose not to, for a real reason" from "I avoided it," and you're honest about which one it was.
If this is your weak spot. Tempted to rewrite the day so you come out looking productive? Let the system do the diff, not you, so the comparison is mechanical and you can't fudge it. The one rule that keeps this gate honest: you don't get to change this morning's focus after the fact. It said what it said. Did that happen, yes or no.
Failure modes. Editing the morning goal at night so you always "hit" it, which is the most common way these systems quietly die. Counting a busy day as a good day when none of the busyness moved the one thing. Skipping the reckoning because you already know you'll feel bad, which is precisely when you most need it.
Example. The one that stung: for weeks I "planned" to wire a failure notification into LeadSurface's classify queue. Every morning it was plausibly on the list, and every night the log showed I'd done something adjacent instead, a small feature, a tweak, real work that wasn't that. The reckoning gate wouldn't let me pretend. It diffed the log against the focus and incremented the deferral, night after night, and the growing count was the thing my memory would have smoothed over. Meanwhile the actual queue backed up past 1,500 items in production because the very notification I kept deferring didn't exist. The gate was telling me, in a rising number, that I was avoiding the exact task whose absence was about to bite. I'd have told myself I was "getting to it." The count told the truth.
Gate 4 — Am I avoiding this?
The gate. This task has been deferred three times or more. Is it actually a priority you keep dodging, or a thing you should admit you're never going to do?
Mode. Pattern.
When you're at it. Triggered, not scheduled. The moment a deferral counter crosses three, the system stops being polite and raises it.
What the loop hands you. A pattern alert. The task, the number of times you've deferred it, and a direct question instead of a gentle reminder. It also checks the miss against the avoidance patterns you named back in Gate 0.
The decision. Kill it or commit to it. Re-commit with a real, specific reason and a slot, or take it off the list honestly. What you don't get to do is let it ride at a low simmer forever, which is the state where it costs you attention every single day without ever getting done.
What good judgment looks like. You treat a 3-plus deferral as information about you, not about the task. You ask which of your named patterns this is, infrastructure over output, research without shipping, and name it out loud. You're willing to delete a task you've carried for a month, because carrying it was the cost, not doing it. When you re-commit, you attach a reason strong enough that tomorrow-you can't wriggle out.
If this is your weak spot. Avoid the avoidance gate itself? This is the one the whole system is built to force, so let the trigger do the forcing, it fires without your permission at three. When it fires, answer one question honestly: if I've dodged this three times, is that the task's fault or mine. Then either it dies today or it's the primary focus tomorrow with a reason attached. No third option.
Failure modes. Letting the alert become wallpaper, so a 6-deferral task is just a number you scroll past. Re-committing with a vague "yeah I'll do it" that defers it a fourth time. Never killing anything, so your list is a museum of good intentions that taxes you daily.
Example. The most honest pattern the system ever caught was me avoiding the system. "Do the weekly review" is itself a named avoidance pattern of mine, skipping the weekly review, because it breaks the pattern detection that makes the whole loop work. Sure enough, the weekly pass is the thing I've deferred most, and watching that specific deferral count climb was the loop indicting its own maintenance. Other times it's a personal project, a golf-content brand name I "kept meaning to finalize" for a month, which at three deferrals I finally had to admit wasn't a priority and cut. The gate's gift is that it converts a vague background guilt into a specific number and a forced choice. Three strikes, and I either name why it matters and give it tomorrow, or I let it go and get the attention back.
Gate 5 — What's tomorrow?
The gate. Given how today actually went and what's piling up, what's tomorrow's one thing, and what do the deferrals demand?
Mode. Commit.
When you're at it. Right after the reckoning, while the day's truth is fresh. Setting up tomorrow-you to start cold without reconstructing anything.
What the loop hands you. A proposed plan for tomorrow, one primary and two secondary, built from today's misses, the open goals, and any deferral that's now demanding a decision. A durable artifact you can pick up cold.
The decision. Commit to tomorrow's one thing now, so the morning is a start and not a negotiation. Explicitly handle any 3-plus deferral, re-commit it with a slot or cut it.
What good judgment looks like. You set tomorrow while today is still honest, before the memory fades and the excuses form. You put the deferred-but-important thing first, because the whole reason it's deferred is that it never wins a fair morning fight. You write it durably enough that a two-day gap doesn't erase it, which is the real superpower in a fragmented life.
If this is your weak spot. Never plan ahead? Let the system draft it from today's reckoning so planning is editing, not inventing. The key move: put tomorrow's plan somewhere tomorrow-you will actually see it at the start of the window. In the margins you don't get warm-up time. The plan being right there is the difference between shipping and spending your one hour remembering where you were.
Failure modes. Starting every morning from zero, burning your best minutes on reconstruction. Letting the deferred item drift to tomorrow's list without a decision, so it just resets its dodge. Planning an ambitious tomorrow that ignores how today actually went.
Example. This gate is what makes the margins survivable. I can stop after the plan, walk away, and come back two days later without losing the thread, because the plan is a durable artifact and not a fading intention. When I next get a window, I don't reconstruct anything. The plan says the one thing, the deferrals I re-committed to are already sorted, and I start building instead of remembering. And it's where the avoidance gate's output lands: a task that hit three deferrals doesn't get to quietly reappear as tomorrow's item four. It's either tomorrow's primary with a reason I wrote while I was still being honest, or it's gone. Planning tomorrow at night, in the light of the real day, is how I keep tomorrow from inheriting today's comfortable lies.
Gate 6 — What patterns emerged?
The gate. Across the whole week, what do the deferrals, the gaps, and the alignment actually say, told straight?
Mode. Pattern.
When you're at it. Once a week. The zoomed-out view the daily gates can't give you, because a pattern is invisible one day at a time.
What the loop hands you. An aggregated, deliberately unflattering summary: which tasks you deferred two or more times, which days had no log at all, and what percentage of the work you actually did maps to a stated goal. Signals, not congratulations.
The decision. Read the week honestly and let it change next week. Which pattern is real, which goal is being starved, which avoidance is now a habit. This is where the system learns about you, but only if you let the numbers land.
What good judgment looks like. You look at the alignment score without flinching, even when it says most of your week went to things no goal needed. You treat a run of logging gaps as data, not a character verdict, and ask what made those days fall out of the loop. You let a repeating deferral graduate into a named pattern, which is how the loop gets smarter about catching you next time.
If this is your weak spot. Hate the weekly zoom-out because it's where the uncomfortable truth lives? Make it mechanical and short, let the system produce the numbers so you're reacting to a report, not grading yourself from memory. Read three things: the alignment percentage, the worst deferral, and the gap days. That's enough to steer the next week. You don't need the whole examined life, just the honest signal.
Failure modes. Skipping the review, which is skipping the only gate that sees patterns, so you repeat the same month indefinitely. Reading the signals and rationalizing each one away. Chasing a cheerful summary that tells you what you want instead of what happened.
Example. The weekly score is the mirror I most want to avoid, which is exactly why it's here. There have been weeks where I logged a satisfying amount of work and the alignment number came back low, because almost all of it was tooling and infrastructure and almost none of it moved LeadSurface or shipped a post. One honest week, the report was mostly "you built systems, including this one, and shipped little." That's the infrastructure-over-output pattern caught in the act, and no single day would have shown it to me, each day's infra work looked reasonable on its own. The weekly gate is also where the logging gaps confess: the days I dropped out of the loop entirely were almost always the days I was avoiding the reckoning, which is its own signal. Told straight, not cheerfully, the week is the smallest unit where my real patterns are visible.
Gate ∞ — How much of this loop does today deserve?
The gate. Which of the daily gates does today actually need?
Mode. Above the others. This is the master gate, and it decides how much of the rest to run.
When you're at it. Every day, before you start. The first decision, and the one people skip because it doesn't feel like a decision.
What the loop hands you. Nothing. There's no prompt and no artifact. The loop will run exactly as much ceremony as you invoke, from a single logged line to the full morning-reckon-plan cycle, and it won't tell you which was right for the day you actually have.
The decision. Right-size the loop to the day. A day with one exhausted hour earns a one-line log and nothing else. A normal working day earns morning, reckon, and plan. A Sunday earns the weekly pass. Getting this wrong is expensive in both directions. Full ceremony on a dead day makes the system feel like a tax and you'll abandon it, and no reckoning on a week that's slipping is how the avoidance goes unseen.
What good judgment looks like. You read the day you actually have, not the day you wish you had, and set the process to match. You're comfortable running the whole loop on a real working day and skipping to a single line on a brutal one. You never confuse "I performed the ritual" with "I moved the thing," which is the exact trap a system like this sets for a person like me.
If this is your weak spot. This is the one gate you can't hand to the system, because it's the decision about how much to trust the system. The starter rule: if today had real working time, run morning and reckon at minimum, because those two are where the honesty lives. If today was survival, log one line so the thread isn't lost and let the rest go. When unsure, do the reckoning, it's the cheapest gate and the one that keeps you honest.
Failure modes. Running the full ritual every day until it feels pointless and you quit the whole thing. Skipping the loop entirely on the hard days, which are the days the loop was built for. Doing the ceremony and mistaking it for the work, which is this system's version of building infrastructure instead of shipping.
Example. The sharpest lesson this whole framework taught me is that it can become the avoidance it was built to catch. For a stretch, I was spending the front of my one good hour tending the accountability system, refining the ritual, tuning the skills, polishing the very loop you're reading about, and calling it productivity. It was infrastructure over output wearing the costume of discipline. Gate ∞ is the fix. Most days now I ask what the day can actually hold, and the honest answer is often "log one line and go build," not "run the ceremony." The loop that earns its keep is the smallest one that keeps me honest. The day I'm doing the whole ritual to avoid the hard hour of real work, the master gate is supposed to catch me, and when I answer it honestly, it does.
Appendix — the state, and running it (disposable)
What actually stores all this, offered as a snapshot and nothing more. This layer is deliberately boring and swappable, and it is not the method.
The whole system is three plain files:
goals.md— the Gate 0 output: your few goals, your named avoidance patterns, your standing constraints.patterns.md— the deferral log and the patterns the weekly gate has surfaced. This is where the counting lives.daily/YYYY-MM-DD.md— one per day: the morning focus, the log, the reckoning, tomorrow's plan.
That's it. Plain markdown, versioned in git if you want a free audit trail, editable by hand if the agent isn't around. If you already keep an Obsidian vault, the loop uses that instead and writes to your daily notes. There's no database, no account, no subscription, and nothing that reprices next quarter. The gates above are the product. The files are just where the honesty gets written down, and when I inevitably rebuild the files next year, the gates won't change.
Related
- Loop & Gate — the framework and the whole stack this guide belongs to.
- The Build Field Guide — the loop on your code.
- The Grow Field Guide — the loop on your market.
- Building on the Margins — the manifesto this all sits under.