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 the honest update: 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. Three fears, and a loop for each.

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 stopped summoning it and put it on a timer.
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 risks nobody actually said out loud. And I wake up to it. 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 shift is small but it's the whole point. A second brain that only works when you remember to use it is just a nicer 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

A few things from the first version held up, and I'd lean into them harder.

The vault is still written for agents, and I'm the side effect. That's still the load-bearing idea. Markdown, one folder per project, a small state layer the agent reads first every session. Boring on purpose.

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. I've just stopped being surprised by it.

What I got wrong

This is the part the setup guides skip.

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. I caught it, but the lesson stuck: the moment you let something write and sync while you're not looking, "what could it accidentally share" is a question you answer before you turn it on, not after. Now anything sensitive lives in a space the sync can't reach, and the automation only touches the safe layer.

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 night 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. The thing that's helped most here is realizing that not everything deserves the same amount of me. I've started tagging things along two lines that turned out to be separate. One is whether I actually read a doc myself or whether it just feeds other docs I read, because a research dump an agent consumes doesn't need to be written for me at all. The other is whether a decision needs me or is just happening around me and I need to note it. A decision I own and a decision that might land on me later are not the same weight, and when I stopped treating them the same, the brief got shorter and the parts that need me stopped hiding behind the parts that don't.

And the seams leak. 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. A vault, 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 whose only job is to disagree, 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 know, do, and 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.