I want to tell you about a Sunday in February, when I spent four hours building an automation for a task that only takes twelve minutes to do manually.
I wasn’t stupid about it. I had a reason: if I could automate the twelve-minute task, I’d have twelve extra minutes every time it came up. Multiply that across a week, a month, a quarter, and suddenly you’re recovering real time. The math checked out, and the motivation was legitimate. By 6 pm, I had a workflow diagram, a webhook that kept timing out, and the original task still sitting in my queue because I’d been too busy building the system to actually do the work.
My wife asked what I’d gotten done. I showed her the diagram.
She nodded politely and said nothing. That doesn’t surprise me. I get really excited about the diagrams and things I create, like EditText.App, but I’m often the only one among my family and close friends who feels that way.
While I was looking for ways to improve my AI agent’s sourcing abilities, I found a study published in Harvard Business Review that suggests that rather than making work easier, AI may be causing what researchers term “brain fry.”
That got me thinking about how I was spending my time with the latest tech stack, you know, all those AI agents like OpenClaw and others. Instead of letting the machines do the work, I was spending a lot of time babysitting them, making sure they didn’t hallucinate, misunderstand instructions, or just make a bigger mess than necessary.
Over the past few months, I’ve tested at least 15 AI agents. Different tools, different use cases, some designed for research and summarization, some for content generation, some that were supposed to handle the kind of low-level decision-making that eats up thirty minutes a day in email triage.
I went in as a believer. I still am, in some long-run sense. But somewhere around agent number eight I started to notice that the time I was “saving” kept getting absorbed by something I couldn’t quite name.
The workflows multiplied. The actual client work didn’t change. My output, measured by things with deadlines attached to them, stayed roughly flat while my Notion workspace got increasingly elaborate. I kept optimizing the system that was supposed to free me up to do the work, instead of doing the work.
I’m not sure when I noticed the gap. Probably sometime around the time, when I realized I’d spent an entire Sunday morning configuring an agent to help me write faster content for websites and produced nothing writable by noon.
The screenshot is already the product
There’s a psychological mechanism called effort substitution, and it’s not a fringe idea. Research published in the Journal of Consumer Psychology in 2011 by Moty Amar and colleagues found that people who planned to accomplish a goal reported meaningfully lower motivation to actually pursue it afterward. The planning itself discharged some of the psychological pressure. You got partial credit from your own brain without doing the thing.
AI tools didn’t create this problem. But they gave it a much nicer interface.
Before, performing productivity looked like: color-coded calendars, elaborate to-do apps, journaling about your goals in a Moleskine. Those things could at least pretend to be preparatory.
The AI version looks like: a multi-agent pipeline that summarizes your inbox, drafts your LinkedIn posts, and schedules follow-ups based on email sentiment analysis. It’s harder to dismiss as mere performance because it involves real technology that does real things. The tool is actually running. Code is actually executing. You’re not just drawing boxes in a notebook; you’re watching logs scroll by in a terminal.
Which is exactly what makes it more dangerous as a substitution mechanism, not less.
LinkedIn rewards the aesthetic of process. I’ve seen screenshots of workflows that have to take two hours to build, but those people received three times their usual engagement of posts describing actual results they spent three weeks producing.
The platform isn’t optimizing for you sharing what you accomplished. It’s optimizing for the thing that makes other people feel like they’re behind. A complicated-looking agent diagram does that. A business outcome usually doesn’t photograph well.
There’s a whole conversation about why LinkedIn specifically amplifies this that I’m not going to get into, but I’ll say this: it’s not just LinkedIn. Reddit productivity threads, Hacker News threads about someone’s personal OS, the YouTube genre of “my complete 2026 productivity system” - they all reward the same thing. They all reward the showing of the work, not the work itself. AI just made the showing more impressive-looking than anything we had before.
And here’s something I’ve been sitting with and can’t fully resolve. I wonder how much of this predates AI entirely. The productivity genre has been selling systems over outcomes for decades. Getting Things Done came out in 2001 and spawned an entire sub-economy of people who spent more time refining their GTD implementation than they spent doing the tasks the system was supposed to capture.
Maybe the AI agent trend is just the latest iteration of that. Or maybe the speed and sophistication of current tools have crossed some threshold where the substitution effect is qualitatively different. I genuinely don’t know. But I notice the problem more now than I did five years ago, but I can’t tell if that’s because the problem is bigger or because I’m paying more attention.
What effort substitution actually does to a brain mid-task
The Jean Baudrillard reference in a lot of online productivity discourse is a bit overstated, but it’s pointing at something real. A simulacrum, in Baudrillard’s framework, is a representation that has replaced the thing it was supposed to represent. The map becomes the territory. In this context: the workflow system becomes the work.
Your brain doesn’t experience this as deception. That’s important. You feel productive because you are doing something. The agent is configured. The prompt is engineered. The integration is live. These are real actions that required real effort.
The prefrontal cortex doesn’t have a clean way to distinguish between “effort that produces an outcome” and “effort that produces the appearance of an outcome,” especially when the tool in question generates convincing output.
A 2014 study from the University of Michigan by Ethan Kross found that self-distancing, the act of reflecting on yourself in the third person, reduced emotional intensity and helped people analyze difficult decisions more clearly.
I think about this whenever I watch myself evaluate my own workflows. I can’t fully self-assess here. I don’t have a good read on whether my agent stack is saving me time in any net sense, because the act of building and maintaining it feels like legitimate work even when it isn’t producing legitimate results.
The specific failure mode I see most: I’ll set up an agent to summarize emails I should be reading directly. Not because I get too many emails to read, but because reading emails I might need to respond to creates a kind of low-level anxiety that the summarization layer delays. The agent isn’t saving me time. It’s managing my discomfort. There’s a difference, and I kept pretending there wasn’t.
A friend of mine, Tomáš, who runs operations for a mid-sized logistics firm in Brno, told me something similar last spring. We were at a dinner that had nothing to do with any of this, talking about something else entirely, and it came up sideways. He’d spent six weeks building a dashboard that aggregated all his key metrics in one place.
Beautifully designed thing, real-time data, color-coded thresholds. Then he told me he mostly didn’t look at it. He was getting updates from his team verbally instead. He’d built the dashboard to feel in control, and once he felt in control he didn’t need the dashboard. I don’t know if this proves anything. His situation is unusual because he had the resources to build it properly, which most people don’t. But the dynamic stuck with me.
Babysitting the thing that was supposed to free you
This is what actually happens when you run agents at the level most people are describing online: They break. Not dramatically, not in ways that are easy to diagnose. They drift. A workflow that ran correctly for three weeks takes a random path on a Wednesday morning and produces output that’s 80% right, which is somehow worse than output that’s obviously wrong because 80% right takes longer to catch and fix.
I’ve had a research agent start hallucinating citations that looked plausible enough that I almost posted them. I caught it because I happened to read closely that day. And let's face it, we don't always read things closely, especially on days we're tired.
One of the agents I tested for about six weeks was built for lead research. The idea was simple: give it a list of company names, it pulls relevant context from a few sources, formats a brief for each one. First two weeks, worked great.
Then it started pulling information from the wrong companies, confusing similarly-named entities, and returning confidently formatted briefs that were factually backwards. I didn’t notice for four days. In those four days, I had two calls where I walked in with the wrong prep. The agent cost me more credibility than the time it saved.
I want to be fair here; that might have been a prompt engineering problem. Maybe better guardrails would have caught the entity confusion earlier. But that’s sort of my point. The tool requires ongoing investment just to maintain basic reliability, and the investment isn’t visible on the dashboard where you’re tracking your “hours saved.”
So you watch, you review outputs. You check that the tool did what you told it to do. And the watching and reviewing takes time, except it’s worse than doing the task yourself would have been because now you’re doing two things: the oversight work and the mental load of trusting a system you’re not sure you can trust.
I want to push back on something I see constantly online. The people claiming they have hundreds of agents running autonomously and generating significant revenue without meaningful supervision are mostly either lying about the supervision part or working in extremely narrow, well-defined domains where the failure modes are small and bounded.
Autonomous content generation at scale without human review produces confidently wrong material. Autonomous outreach at scale without human oversight produces messages that annoy people on your behalf without your knowledge. The “agentic future” some people are describing isn’t here. The models aren’t reliable enough for the level of autonomy being claimed.
A 2025 report from Stanford's Human-Centered AI group found that AI coding agents complete multi-hour task benchmarks with roughly 50% reliability. More striking: a randomized trial included in the same report found that experienced open-source developers took about 19% longer to complete work when they had access to frontier AI tools than when those tools were taken away. Not 19% faster, longer.
I should say: I’m not sure the coding context maps cleanly to the kind of business workflow automation most people are actually running. Coding tasks are more measurable than most agent use cases, which makes them easier to benchmark but also a bit cleaner than real-world conditions.
The 50% reliability figure has stayed in my head anyway, because it matches what I’ve experienced, and the developer slowdown finding is harder to dismiss.
The overhead compounds in ways that are hard to see in the moment. You spend forty-five minutes configuring the agent. Another thirty debugging when it fails the first time. Twenty minutes a week on monitoring. An hour here and there on prompt adjustments as the underlying model updates change behavior slightly.
Annualized, you may have spent more time on the infrastructure than you’d have spent doing the task the old way. The time savings are real in theory and often negative in practice, and the negative in practice part is invisible because it shows up as “agent maintenance” rather than “time I could have spent working.”
I’m not saying don’t use them. I’m saying the math you’re doing in your head when you adopt one is probably wrong.
What the twelve-minute task was actually about
The question I find myself sitting with isn’t “which agents are worth it.” That’s solvable with enough testing. The question is harder: if I stripped out every tool that makes me feel productive and only kept the ones that produce verifiable outcomes, what would be left?
I’ve been afraid to actually run that audit. That’s data.
There’s no crisp takeaway here about which workflows to cut or how to structure your agent oversight process. Plenty of people will sell you that. What I keep coming back to is the older, less satisfying question that the AI productivity conversation keeps stepping around: what are you actually trying to avoid doing, and is the thing you’re building making it easier or harder to avoid doing it?
For me it was the twelve-minute task on that Sunday in February. Not because twelve minutes was too long, but because doing it meant looking at a set of numbers I didn’t want to look at. The automation wasn’t about efficiency. It was a very elaborate way of not opening a spreadsheet.
There’s a version of this that’s genuinely hard to answer. Some tasks really do deserve automation. Some friction is real friction, not psychological avoidance dressed up as friction. I don’t have a reliable method for telling the difference in the moment.
What I notice is that when I’m excited about building a workflow, that excitement is sometimes about the problem being solved and sometimes about not having to confront what happens after it’s solved. The second kind of excitement has a slightly different texture, a little more restless, a little quicker to check how the tool looks rather than whether it’s working. I haven’t figured out what to do with that observation beyond noticing it.
The models will get more reliable. The tooling will catch up. Some of the oversight burden will come down as the agents get better at knowing when to ask for help versus when to proceed. I’m genuinely optimistic about the three-to-five-year picture.
But right now, most of what’s being called “autonomous” is just latent human supervision wearing a different costume, and most of what’s being called “productivity gains” is the pleasant feeling of configuring something that might, eventually, save you time.
The twelve-minute task is still in my queue, by the way. I did it last Saturday. Took eleven minutes. The numbers were fine.
Do not believe the hype; it is full of bugs.
The agent audit I ran after wasting six months on automation
The exercise I’m about to describe took me about three hours the first time and produced results I didn’t show anyone for two weeks because they were, lets say… embarrassing.
The setup: I went through every automated workflow I was running and, for each one, tried to answer a single question honestly. Not “does this save time in theory” - I’d already convinced myself the answer was yes for all of them, which is how I’d ended up with fourteen active workflows.
The question was: What verifiable output has this produced in the last 30 days that I couldn’t have produced without it?
Verifiable. That word does a lot of work. Not “it probably saved me an hour on that one thing.” Not “I haven’t had to manually do X since I set this up.” Verifiable output. Something I could point to. A document, a decision, a completed client deliverable, a deal that moved forward. Something real that exists now and didn’t before.
One clarification on the framing, “couldn’t have produced without it” doesn’t mean “it would have been theoretically impossible.” It means “I have strong evidence I wouldn’t have actually done this, based on my prior behavior before the automation existed.” That distinction matters. A lot of things are possible that don’t happen.
Seven of my fourteen workflows failed that test immediately. Not kind of failed. Failed completely; I couldn’t name a single concrete output they’d produced in a month.
The email triage agent was the first one I wanted to defend. I’d been running it for four months and I genuinely believed it was saving me time. The agent categorized incoming emails, surfaced the ones that needed same-day responses, and deprioritized newsletters and FYI-type messages into a separate folder.
What I found when I looked closely: I was reading almost every email anyway. The categorization was informing maybe fifteen percent of my actual decisions about what to respond to. I was checking the “deprioritized” folder constantly because I didn’t trust the agent’s judgment, which meant I was essentially doing the full email triage myself and then also glancing at the agent’s categorization. I wasn’t replacing the work. I was doing the work plus a layer of output validation.
Time cost per week: approximately 40 minutes for the original triage I was still doing, plus 20 minutes reviewing the agent’s work and correcting the cases where it was wrong. Before the agent, the manual triage alone took maybe 45 minutes. I had added 15 minutes a week net and convinced myself I was saving time because the agent’s interface felt productive.
That last part is the thing I find hardest to explain to someone who hasn’t experienced it. The interface is doing something. The logs are scrolling. The categories are populating. The experience of watching it work produces a feeling that is functionally indistinguishable from the feeling of having done useful work yourself, at least in the moment.
I turned it off. The next week felt slightly anxious but the work got done at roughly the same rate.
The content summarization workflow was harder to evaluate because the output was less defined. The agent was supposed to read industry articles and pull out relevant points for a weekly roundup I wrote for clients. The idea was good.
The implementation had a problem I hadn’t fully confronted: the summaries the agent produced were accurate but flat. They extracted claims without context, stripped out the texture that made an article interesting, and returned bullet-pointed facts that I then had to re-read the original articles to actually understand well enough to write about.
So I was reading the summaries, then reading the articles anyway, then writing from the articles directly. The summaries had become an intermediate step that added time without adding information. They also had a subtler effect: because I’d already “processed” the article through the agent, I felt less urgency to engage with it closely. The summary created a false sense of having done the reading.
There’s a relevant finding from Pam Mueller and Daniel Oppenheimer’s 2014 research at Princeton and UCLA, published in Psychological Science, comparing students who took notes by hand versus laptop. Laptop note-takers retained less, not because they were distracted, but because they transcribed more verbatim. The act of capturing information word-for-word replaced the act of processing it. The notes were more complete. The understanding was shallower.
The AI summary problem has the same structure. The summary is more complete than anything I’d have written by hand. The comprehension is worse because the processing happened somewhere else.
The content summarization workflow is now off. I read fewer articles but actually remember what I read.
Three workflows survived the audit. I’ll describe them briefly because they’re narrow and probably not generalizable, but the common thread is interesting.
The first is a simple one: an agent that pulls all my outstanding invoices and payment statuses into one place every Monday morning. I used to do this manually, which meant I often didn’t do it, which meant I sometimes had unpaid invoices sit for three or four weeks before I noticed.
The pattern was embarrassing. I’m reasonably detail-oriented about most things but I have some kind of aversion to the administrative side of invoicing that I’ve never fully explained to myself. The agent removed a task I was reliably avoiding. Verifiable output: I now have a consistent view of cash flow every week and collect payment faster. I’ve measured this. It’s real.
The second is a webhook that logs every time a specific client portal is accessed. This replaced a process where I was manually checking access logs once a week and often forgetting. The agent doesn’t make decisions. It observes and records. Very narrow.
The third was a content repurposing workflow that took finished articles I’d already written and reformatted them for different platforms. I kept this one with reservations. The output quality is okay but not great, and I spend about thirty minutes editing each output before it’s usable.
The jury’s still out on whether the reformatting time plus editing time is actually less than just writing a fresh, shorter version from scratch. I’ve been meaning to measure this directly for two months and keep finding other things to do, which is probably itself diagnostic.
The pattern across the three that survived
They handle tasks I was already reliably failing to do manually, and they produce outputs I can verify without needing to redo the underlying work. They’re not productivity amplifiers in the aspirational sense. They’re accountability structures for specific things I was dropping.
That reframe matters; the best automation I have isn’t impressive. There’s no diagram worth screenshotting. It just quietly prevents a known failure mode. That’s almost the opposite of what the agent hype cycle is selling, which is capability expansion, doing more and better work, not just not failing at the basic stuff.
The workflows that failed the audit were different. They were automating tasks I was actually doing, adding a layer of AI processing that I was then also doing, and creating the impression of sophistication around processes that were working fine or not working for reasons the automation didn’t address.
There’s a version of the audit that would probably surface different results for you, depending on what you’re actually using and what you’re actually avoiding.
I’m not claiming fourteen workflows is too many or that email triage is never worth automating. The number isn’t the point. The question, “what verifiable output has this produced in 30 days that I couldn’t have produced without it,“ that’s the point.
Some things will survive that question easily. Some will fail it immediately. A few will be genuinely hard to evaluate, which is itself informative. If you can’t describe what success looks like for a workflow, you set it up before you knew what you needed it to do.
I’ll probably run this audit again in six months. The stack will have grown again by then, I know myself well enough to predict that with confidence.
And I’ll probably find the same basic pattern. A few workflows that are genuinely earning their place, and several that are doing the work of making me feel like someone who has things organized, which is not the same thing at all.





