My PM Brain Runs on Fear: The Loops I Built Around It

An update to https://dev.to/praneetaprakash/how-i-product-aec

My PM brain is running in constant loops, and things that fuel it are different fears - fear of missing out, fear of making the wrong bet, fear of dropping the wrong balls in the air. A few months ago I wrote about how I started treating product decisions/docs/research as we treat code - shareable in its intermediate states, reviewable, rollback-able and agent-friendly. Because if you think about it, decisions are encoded in how we form our words together, and agents can understand these. I've been running that system every day since. It got a lot bigger. Some of it worked better than I expected. Some of it broke in ways I didn't see coming. This is V2: what stuck, what I got wrong, and adding loops.

The loops are the fears

That first post was mostly about runs I started by hand. I'd point agents at a doc in the vault and they'd stress-test it, and I'd rewrite, and that was useful, but I was still the one starting every loop. Which meant the loop only ran when the fear happened to surface while I was sitting at my desk. So the thing I actually changed this time was letting each fear run on its own schedule instead of running on my memory.

Fear of missing out, and the ingestion loop

This is the fear that a decision I care about is being made somewhere I'm not looking. So now the conversations I get pulled into get pulled into the vault on their own every day, and they get sorted into what I need to know, what I need to do, and what I should be worried about, before I even open my laptop. I also provided programmatic access to Slack's own AI to hand me the "what needs your attention soon" list, because it's honestly better than I am at spotting what's aimed directly at me. The fear didn't go away, it just stopped depending on me refreshing Slack at 11pm.
A quick note here - I read some tweets recently about moving conversations into channels rather than DMs, and I am planning to do that as well. In the world with agents ingesting Slack, this becomes critical for success.

Fear of making the wrong bet, and the skeptic loop

I have an agent I call the Impactful Jerk, and its whole job is to disagree with me. It used to only run when I called it, which if you think about it means it only ran when I already suspected I was wrong. Now it runs every night against my actual project state and tells me where what I say is the priority and what's actually happening have drifted apart. It caught me writing that a decision was "locked" when it had quietly been reopened days before. A skeptic you have to summon is useless exactly when you need it, which is when you're confident, so I automatically run it for every strategy shift detected when looking at slack decisions or project boards.
A side note here - I set up a "startup" version of the impactful jerk for friends, and having the skeptic voice out strategy challenges in early days is incredibly helpful.

Fear of dropping the wrong balls, and the brief loop

Everyone drops balls, and the fear isn't that, it's dropping the one that was holding something up. So overnight the system puts together one page for me: what changed, what I owe people and by when, and the possible fires. It's not that I couldn't track these things myself, it's that the tracking kept competing with the thinking, and the thinking always lost. The minute busy work started taking up my precious time.

A second brain that only works when you remember to use it is just a nicer markdown folder. The value showed up when the loops started closing on their own, when the fear stopped being the thing that kicked off the loop and the loop became the thing that answered the fear.

What stuck

The vault is still written for agents with Claude/Kiro working with Obsidian, checked into git. One folder per project, a small state layer the agent reads first every session, decay rules for overridden decisions, links to related files.

Code is still how I talk to people. Demos settle debates that docs can't, and the only thing that changed is I make more of them and faster.

And the rewrite moment still happens. Building the thing still reveals that the doc was wrong, every time.

What I got wrong

I automated before I put any guardrails on it. I wired the vault to sync on its own so I'd never lose a capture, and it worked great, because it faithfully committed everything, including things that had no business being in a shared place. An agent doing this on a schedule doesn't have judgment about what's sensitive, it just has the equivalent of a save button that fires whether you're watching or not. Now anything sensitive lives in a separate space the sync can't reach, and acts as input to the agents that know how to scrub it.

Confident is not the same as right, and loops make this worse, not better. In the first post I wrote about an agent handing me a number that was technically correct and completely wrong for the context. When you're running things in a loop, a wrong assumption doesn't just happen once, it quietly repeats every time into a page you've started to trust. That's exactly why the skeptic had to go inside the loop, not sit next to it.

And I confused more automation with better judgment. For a while I kept adding agents. The ones that survived aren't the ones that do the most, they're the ones that catch the most. My most useful agent is a professional pessimist.

Gaps I'm still working on

I don't have these solved, and I'm writing them down partly so I actually go do them.

I still read the whole brief, because I don't fully trust any single line of it yet. A page you have to re-verify end to end isn't saving you as much as it looks like it is, so I want each item to carry how confident it is, instead of everything sitting at the same flat level.

What's truly helping is not just the tech, but the rigor it brings with it. I haven't been able to benchmark using my system vs not for product management, its still a gut feel. When a number moves in the right direction, I usually can't separate "the thing I built helped" from "the underlying tools just got better on their own," and I'm suspicious of my own wins because of it.

The loops don't know when to stay quiet. They run on a fixed schedule whether or not there's anything worth running on, and I'd rather they got loud when something's actually urgent and said nothing when it isn't, instead of handing me a tidy page every single day and training me to skim it. To address this, I have started to classify documents I fully need to read, vs documents that make inputs to other docs that I don't need to read. The same as strategy decisions that need my direct attention, vs ambient decisions that might impact me that I need to note. The degrees matter, and you decide how to design those into your system.

It's not perfect though, every tool I stitch together drops something at the boundary, a link here, an ID there, and the whole system is only as reliable as its weakest seam. I haven't fixed those yet.

The setup

If you want to run something like this, the bones are the same as last time, a folder of markdown, an AI tool that can read it, and one file that tells it how. What's new is the loop layer on top:

1. An Obsidian vault, rules for your agent to store all things as markdown, one folder per project, a small state layer the agent reads first.
2. A context rule, one file telling the AI how to use the vault before it answers anything.
3. A skeptic agent whose surfaces hard critique and gaps, and run it inside the loop, not just when you ask.
4. Scheduled ingestion, so the conversations you're in come to you sorted into must-know, must-do, and must-worry-about.
5. A private context storage the automation can't sync, and decide this before you automate writing, not after.
6. A morning brief, one page, made overnight, that you're allowed to distrust.

The job didn't change, and the fears didn't go away either, and I don't think they're supposed to. What changed is that each one now has a loop pointed at it that keeps running when I'm not. The hard part was never building the loops, it was teaching them what not to do, and learning to trust a page I didn't write.