Make the Agent Keep a Diary: Four Headings, Thirty Seconds, Real Audit Trail

Jenny Wanger shipped an agent audit trail that fits in four markdown headings. What Was Built or Changed. Key Decisions Made. Mistakes or Errors. Next Steps. The agent fills them in at the end of a session, appends the entry to a log file, and the operator closes the terminal. Her own measure of the format: “Each entry reads in about thirty seconds.”

She built it while driving AI adoption across a client’s 50 product managers. The rollout ran through product management rather than engineering, which shaped what the artifact had to survive. Fifty people with no shared toolchain, no CI to hang a hook on, and no patience for a governance program that arrives as a slide deck.

The reason she gives is short. “You can’t improve what you can’t see. Most AI use is invisible.” The more useful line is the one about how that invisibility feels from the inside: “When sessions evaporate the moment I close the terminal window, I’m left with a nagging feeling that I’m either a power user or a fraud.”

That feeling is nearly universal among people running agents daily, and almost nobody has an artifact that resolves it.

The Four Headings

The format is fixed, and the fixity is the design. What Was Built or Changed captures the output. Key Decisions Made captures the choices that will look arbitrary in three weeks. Mistakes or Errors captures what went wrong. Next Steps captures the thread you were holding when you stopped.

She shipped it as a Claude Code skill, published at github.com/jennydove/self-improving-claude. The delivery mechanism carries more weight than it appears to. A slash command costs one keystroke at the end of a session, and one keystroke is roughly the entire budget available at that moment. Documentation practices that cost more than that do not survive contact with a Friday afternoon.

Compare this to every other agent governance artifact currently being proposed. Telemetry pipelines, policy engines, memory audit APIs, identity federation for workloads. All of them are real work, most of them are correct, and none of them can be adopted between lunch and the next meeting. This one can.

The Mistakes Section Is the One That Pays

Three of the four headings are recall. You write them so that future-you can reconstruct why the schema looks like that, or so Monday-you can resume Friday’s thread without re-reading a diff.

The Mistakes section does something else. It accumulates evidence about the operator.

Read twenty entries in a row and a pattern shows up on your side of the keyboard: the tasks you hand over with too little context, the constraints you assumed were obvious, the point in a long session where you stop reading output carefully. The agent’s errors are the visible half of a delegation habit. Model capability is the boring explanation and usually the wrong one, because the same model produced excellent work in the entry three days earlier under a better brief.

This is the part a generic “log your AI work” practice misses. The log is not primarily a record of what the agent did. It is a slow-accumulating dataset about how you delegate, and delegation is the skill that determines whether an agent program compounds or plateaus.

Her method for reading it back is deliberately low-effort: let it run for two weeks, then ask your AI to read the log. The first reader is the operator. The first use is self-review. Everything else that the log enables comes later, and she names four of them: a first draft of the weekly stakeholder update, session recovery after a context loss, annual self-review, and 1:1 agenda prep.

That list is worth pausing on, because it explains the economics. The entry costs thirty seconds of agent output. It pays back four separate times in artifacts you were going to produce anyway, badly, from memory.

The Privacy Constraint Is Load Bearing

Wanger closes with a single sentence of governance: “Just don’t ask to read anyone’s diary.”

Read quickly, that sounds like politeness. It is the design constraint that makes the whole thing work, and it deserves defending rather than apologizing for.

Audience determines content. A log written where a manager might read it becomes a status report within two entries. The Mistakes section empties first, then flattens into safe items about flaky tests and API timeouts. The section that carried the entire diagnostic value is the section with the strongest incentive to sanitize, and it sanitizes the moment the reader changes.

So the trade is explicit. You give up organizational visibility into the log and you get honest content in it. For the individual operator that trade is obviously correct, because the honest version changes how they work next week and the sanitized version changes nothing.

This is where the practice connects to problems much larger than one person’s terminal. We have argued that the agentic work platform becomes the governance layer and that the best governance is invisible to the person being governed. Both are platform-scale arguments, and both hold. This is their individual-operator counterpart, and it carries a warning for the platform version.

Agent observability programs die when they read as monitoring. The failure is predictable: instrumentation arrives, the dashboard goes up, usage looks great for a month, and then the numbers turn suspiciously clean. People route around a system that grades them. The route-around is cheap with agents, because the vendor-side telemetry sees routes and volumes rather than reasoning, and a session that never gets narrated leaves nothing behind to grade.

The design lesson transfers directly. Whatever you build at the platform layer, keep a surface that belongs to the operator, that no manager reads, and that no performance review touches. Then let people volunteer from it. A product manager who has read her own two weeks of mistakes will bring better material to a 1:1 than any dashboard would have extracted from her.

Is an Audit Trail Nobody Reads Still an Audit Trail

Worth taking the objection seriously, because it is the standard institutional response to anything private.

Audit has two customers. External accountability needs the platform layer: query tagging, immutable logs, identity federation, retention policy. That customer is real, that work is necessary, and the diary does not serve it.

Personal accountability needs something different. It needs a record the operator would actually write honestly, produced at a cost low enough to survive a bad week. That record is what changes behavior, and behavior change is the thing every governance program is ultimately buying. The dashboards are a proxy for it.

An organization that has the platform layer and lacks the personal layer has visibility into a workforce that is quietly optimizing for the dashboard. An organization with both has visibility plus fifty people who each know exactly how they delegate badly.

Do This Today

Add the four headings to your agent’s session-end routine. Use Wanger’s exact wording, since the value is in the fixity and any rewrite you make today will be an improvement you regret in a month.

Four rules keep it alive. Write the file somewhere private, outside the repo or gitignored, and treat that as a hard boundary. Keep the cost at one command. Resist the urge to add a fifth heading. Run it for two weeks before you evaluate anything, then ask the agent to read the log back and tell you what it notices about how you work.

If you manage a team running agents, adopt it yourself first and then say the quiet part out loud when you introduce it: you will never ask to see their file. Ask instead what they learned from reading their own. The answers will be better than anything you could have queried.

This analysis draws on Your AI Should Keep a Diary (Jenny Wanger, July 2026).

Victorino Group helps organizations build agent governance that practitioners adopt voluntarily, from the individual session log up to the platform layer. Let’s talk.