I expected AI to lighten my load. In one way it did: I produce more in a week now than I used to in a month. Drafts, code, landing pages, ad variants, research summaries. As a solo founder running product, engineering, marketing and content, that should feel like freedom.
It doesn't. What I noticed instead is that the number of decisions I make every day went up, not down.
Every draft is a decision. Every pull request is a decision. Every set of five headline options is a five-way decision. AI made production nearly free, so the bottleneck moved to the one thing it didn't speed up: my judgment.
Why it feels worse than before
When I made things myself, the deciding was folded into the making. I chose the angle while I wrote the first paragraph. I settled the layout while I built it. The decisions were spread out and mostly invisible.
Now the making is gone and only the deciding is left, arriving in a concentrated stream. More output means more approvals, and all of them route through one person.
I started out wanting to build an app to fix this. An app that doesn't manage your tasks but minimizes your decisions: it suggests what to do next, and if you don't object, the suggestion quietly becomes the plan. I still like that idea. But the more I looked at my own queue, the more I realized most of what lands on me isn't a decision at all.
Most of it is verification in disguise
There are two different things mixed together in that queue.
Verification asks: is this correct? Does it meet the standard? There's a right answer, so it can be defined in advance and mostly checked by a machine.
A decision asks: which direction do we want? Is this worth doing? What do we give up? There's no right answer without my values, so it stays with me.
"Should I approve this?" feels like a decision. Usually it's "did it do what I asked?", and that's verification. My guess is that most of what AI output throws at me is the first kind wearing the costume of the second.
That changes the plan. Before building anything to help me decide, I should strip out the verification that's pretending to be decisions. What's left is the real decision load, and only then can I see its size and shape.

Where verification should live
My first instinct was that verification belongs in Claude skills files or MCP. That's mostly right, but it misses a piece. Verification needs four things, and they live in different places.

Standard: what good looks like. Lives in skills, plus rules files for what always applies.
Evidence: what's actually true. Lives in MCP tools, or a CLI or API called from a skill.
Enforcement: checks always run. Lives in hooks, scripts, CI.
Independence: the author doesn't grade itself. Lives in a separate reviewer agent.
Skills hold the standard. Acceptance criteria, checklists, examples of good and bad output. They're versioned and reusable. Their weakness is that instructions are advisory. A model can skim a checklist or grade its own work generously.
MCP brings the evidence. Did the tests pass? Does the live page render? Did the event fire in analytics? Does the record exist in Stripe? Without ground truth, the agent is checking its work against its own belief about its work.
Enforcement makes it non-optional. Something has to run the check whether or not the model remembers to: a hook when a task finishes, a script, a gate that blocks "done" until checks pass. This is the part that lets me stop looking.
Independence catches rationalization. A reviewer with fresh context, reading the same criteria and pulling the same evidence, catches what the author talked itself into.
Skills, MCP or rules files?
These overlap more than the list suggests, so it's worth being clear about what each is good at.
Rules files (CLAUDE.md and the like) are always loaded. They suit the handful of rules that apply to every task. Put everything there and every task carries the weight, and the important lines get skimmed.
Skills load only when a task calls for them. That makes them the natural home for "when doing X, done means Y."
For live systems, it's skills plus a CLI or API versus MCP. Plenty of people reach Stripe, analytics or their CMS straight from a skill that calls a CLI or an API, and it works well. It's lighter, cheaper on context and easy to chain. It does need a shell and credentials on the machine running it. MCP earns its place where there's no shell, like claude.ai or mobile, and where you want sign-in handled for you and each tool allowed or blocked on its own.
For verification, the choice matters less than it seems. Either route can bring back the evidence. What matters is that the check runs whether or not the model remembers it, and that comes from hooks and CI, not from any of these files.
Two rules I'm adopting:
Anything code can check, code should check. Links, tests, schema, word count, brand colors. Model judgment is for tone, or whether an argument holds.
Every time I catch something by hand, the fix goes into a skill or becomes a script. A mistake I catch once becomes a check I never do again.
Verification is not evaluation
I used to treat these as the same word. They're not.
Verification checks one output, every time, before it ships. Pass or fail. It's inspecting the product coming off the line.
Evaluation checks the system that makes the outputs: the prompt, the skill, the model, the workflow. It runs across many cases when you build or change something, and it gives you a rate or a score. It's auditing the factory.
They feed each other. The same check run once guards one output; run across a test set, it becomes a metric. Every real-world catch becomes a new test case. And evaluation tells you how strict verification needs to be. If a skill passes 99% of the time, I can spot-check one in ten. If it passes 70%, I check everything.
This is the part I'd been missing. Without evaluation, I never have grounds to stop checking, so I review everything forever. With it, "this workflow is reliable enough to ship without me" becomes a measured claim instead of a hope.
What's left is the real work
Once verification is handled, what remains is direction, taste and tradeoffs. Those are the decisions that should reach me, and they're the ones worth protecting my attention for.
So my plan for the next two weeks is simple. Strengthen verification in my own workflows, then keep a short log of what still reaches me. If the log is short, I've solved it with workflow and saved myself building a product. If it's still a daily burden with a pattern, that pattern is the spec for the decision app, and I'll build it on evidence instead of a hunch.
The number I'm watching isn't how much AI produces for me. It's how many decisions reach me each day, and whether that number is going down.



This is so true because instead of actually saving time, we end up spending all of our energy just reviewing and approving stuff. Thank you for sharing!