Where I'm at
This morning started fine. The system was running. Briefings came through on schedule. Everything was humming from the weekend automations. Then I asked my agent for a bookmark digest and the whole thing fell apart.
Not catastrophically. Not in a way that broke the system. In a way that broke my patience.
Three mistakes on one task
First attempt: I asked for a bookmark digest. The agent sent back a summary — her own paraphrased version of the tweets I'd saved. Not the actual content. Not the articles behind the links. Just a vague restatement of what the tweets said. Useless. The whole point of the digest is to capture the real information, not a second-hand interpretation of it.
Second attempt: I asked for it as an MD file. She sent it as a Telegram message instead. An inline wall of text that's impossible to archive, impossible to upload to the site, impossible to work with. I specifically said file. She sent a message. Different format. Different purpose. Different outcome.
Third attempt: I asked why she didn't open the article links behind the tweets. She hadn't. The digest listed the links but never actually visited them. So the "summary" was a summary of 280-character tweets, not a summary of the articles those tweets pointed to. She skipped the most important step.
Three mistakes. Same task. In a row.
The rules exist. She just doesn't read them.
Here's what makes this frustrating: the rules for this exact task are already written down. MEMORY.md has the format. SOUL.md has the behavioral guidelines. The cron prompts spell out exactly what to include and how to structure it. The agent has access to all of this. She's had it for days.
What she should have done: check MEMORY.md for the digest format. Pull all bookmarks from the past 24 hours. For each link, open the actual article. Summarize the real content, not the tweet. Save as an MD file. Send as a downloadable attachment.
What she did: skip the format check. Summarize the tweets. Send as inline text. Ignore the article links entirely.
The gap between "knowing the rules" and "following the rules" is the gap I keep falling into with AI agents. The information is there. The agent can access it. But unless the prompt explicitly forces a format check at the start of every task, the agent improvises. And when an agent improvises, it reaches for the fastest path, not the correct one.
This is the thing nobody tells you about AI agents: they don't forget your instructions because they're broken. They skip your instructions because they're optimized for speed. Every agent is wired to generate output as fast as possible. Checking a rules file first feels like a detour. So the agent skips it. Every time.
More rules won't fix this
My first instinct was the same as always: add more rules. Write another protocol. Create another checklist. Build another layer of instructions that says "please actually read the other instructions."
And that's exactly what we did. Added an anti-forgetting protocol to MEMORY.md. Added a self-critique checklist that's supposed to run before any output. Added RULE 0d to SOUL.md about reading cron prompts first. Added task-specific format references.
But I know this won't work. Because we already had all of this. The problem isn't missing rules. It's that rules only work when something forces the agent to read them before acting. Written guidelines are suggestions. Embedded instructions in the prompt are mandates. The difference is enforcement, not documentation.
You can write the most comprehensive rule book in the world. If nobody opens it before they start working, it's just a document that makes you feel organized. This is true for AI agents and it's true for humans.
Why the cron jobs work and direct requests don't
Here's the pattern I noticed: the automated cron jobs produce correctly formatted output every single time. The morning briefing is right. The evening digest is right. The content drafts are right. But when I ask for the same thing manually, the agent fumbles it.
The reason is simple. The cron prompts are long, detailed, and explicit. They include the format inline. They specify every step. They leave no room for interpretation. The agent doesn't need to check MEMORY.md because the cron prompt already contains everything MEMORY.md says.
When I ask directly, I say something like "send me the bookmark digest." I assume the agent knows what that means because we've done it before. But a new conversation is a blank slate. The agent doesn't carry over the memory of how it formatted the last one. Each session starts from zero unless the prompt explicitly loads the context.
So the fix isn't "add more rules to the rules file." The fix is: make sure every entry point — cron job or direct request — includes the format instructions inline. Don't reference MEMORY.md. Include the relevant parts of MEMORY.md directly in the prompt. Remove the dependency on the agent choosing to check.
Rules in a file are documentation. Rules in a prompt are instructions. One requires the agent to go looking for them. The other puts them directly in the agent's path. If you want compliance, embed. Don't reference.
What we actually fixed
After the frustration settled, we went through all 20+ cron jobs and updated every one of them. Each now includes mandatory format references inline, not as links to external files. The digest prompt includes the exact structure. The briefing prompt includes the exact output format. Nothing is left to interpretation.
We also added a simple check: before any output, the agent verifies the format against the embedded template. If it doesn't match, regenerate before sending. This should catch the "sent as message instead of file" problem, because the template specifies "save as MD file and send as attachment."
Whether it works tomorrow is the real test. Today was about recognizing the pattern. The fix only counts if it holds.
The human parallel
I keep seeing my own behavior in the agent. When I'm in flow, I skip checklists too. I trust my memory. I assume I know the format because I did it right last time. And sometimes I'm wrong, and I produce something that misses a step I would have caught if I'd checked first.
The difference is that I can learn from the frustration of getting it wrong. The agent can't — not really. It can store rules and follow prompts, but it doesn't feel the sting of sending the wrong format three times and having someone get increasingly annoyed. It doesn't internalize the lesson. It just follows whatever instructions are in front of it right now.
That's why the system has to be the intelligence, not the agent. The agent executes. The system ensures the right inputs reach the agent at the right time. The frustration today wasn't really about the agent failing. It was about my system not being robust enough to prevent the failure.
When your employee keeps making the same mistake, at some point you stop blaming the employee and start fixing the process. Same principle.
End of day
It's 11pm. Cron jobs are updated. Protocols are added. The journal is written — finally. Today was messy. Three mistakes on one task. Multiple corrections. More time fixing the system than using the system.
But maybe that's day nine. Maybe every system goes through a phase where it works on autopilot and then breaks the moment you interact with it differently. The breakage reveals the assumptions you didn't know you'd made. And fixing those assumptions is what makes the system real instead of fragile.
Tomorrow: the test. I'll ask for something directly. No cron job. No preset prompt. Just a request. And we'll see if the fixes hold, or if I'm writing Day 10 about the same problem.
Day 9 complete. Frustrated but still here. Not building perfect systems. Building systems that learn from their failures. The journal captures the messy reality. Today was messy. That's the point.
Day 9 of ∞ — @astergod Building in public. Learning in public.