Automate the Habit, Not Just the Task

Most good engineering habits don’t fail because people don’t care. They fail because the habit asks for effort at exactly the moment there’s none to spare. Write the note after you solve the thing — when you’re drained and already late for the next thing. Update the context file before you close the session — when you’ve mentally checked out. The task isn’t hard; the timing is brutal. The durable fix isn’t more discipline. It’s automating the habit itself, so it happens on an event instead of on willpower.

Willpower is the least reliable trigger you can pick

Any process that runs “when I remember to” is running on the flakiest scheduler in existence. It works great right after you’ve been burned, decays over a few weeks, and is stone dead by the time you actually need what it was supposed to produce. This is why knowledge bases rot, why context files go stale, why the backup nobody automated is the one that wasn’t there. The work competing with the habit always wins, because the work is what someone’s asking for right now.

A practice that depends on remembering is a practice with an expiry date. The only question is how long until it lapses.

So I stopped trying to be more consistent and started asking a different question: what event already happens reliably that I can attach this to?

Bind the habit to an event, and it stops needing you

The move is to hook the habit onto something that fires on its own — a session starting, a file saving, a commit landing, a job finishing. Once it’s wired to an event, it isn’t a thing you do; it’s a thing that happens. Two hooks I lean on constantly:

• A start hook that loads context. When a working session begins, it force-reads the notes and conventions that never change, so I’m never re-explaining the basics. No “let me paste in how this works” every time.
• A stop hook that saves state. When the session ends, it writes down what changed and what’s next, automatically. I touch nothing, and the next session’s start hook has fresh material to load.

Together those two turn a memory file from “documentation I have to maintain” into “memory that maintains itself.” It’s the same read-then-work-then-write loop I use for agents in durable agent context — just pointed at my own workflow instead of a model’s.

Move the human action to the cheapest moment

You usually can’t remove the human entirely — some judgment has to stay. The trick is to shrink the human’s job to the smallest, earliest, lowest-friction signal possible, and let automation do everything after it. The best knowledge systems I’ve seen don’t ask you to file and structure and cross-link. They ask you to do one thing — react with an emoji, tag a note, forward a message — and the machine handles collection, structuring, and synthesis from there.

That reframing is the whole game. Filing a note properly is expensive and competes with your real work, so it loses. Tapping one tag costs nothing and happens in the moment the insight is fresh. Same judgment (“this is worth keeping”), a fraction of the friction — and the vault grows out of work you were already doing instead of a separate chore you’ll skip.

The trade-off is signal quality, so guard it

None of this is free. When the only human input is a single signal, the system is only as good as that signal. Garbage tags in, garbage notes out. A stop hook that writes a lazy, wrong summary quietly poisons the next session. So the effort you save on doing the habit, you spend a little of on aiming it: tag the right things, and sanity-check the automated output now and then. You’re not removing judgment — you’re relocating it to the one place it’s cheap.

There’s also a discipline point hiding here: an automated habit you never inspect can drift silently, which is its own failure mode. The goal isn’t “set it and forget it forever.” It’s “set it so the default is correct, then spot-check that the default is still correct.”

Design the trigger first, the task second

When I want a practice to actually stick now, I don’t start with the task. I start with the trigger: what reliable event can I hang this on so it stops depending on me? Then I make the human’s remaining part as close to zero as I can. Automate the habit, not just the task — because the task was never the hard part. The remembering was. It’s a recurring theme in how I run my AI automation lab: the leverage isn’t a clever one-off, it’s the boring thing that now happens every single time without anyone deciding to do it. If you’ve wired a habit onto an event and watched it finally stick, I’d love to hear which one.