Something strange has been happening lately, I keep forgetting small things.
Not names.
Not conversations.
Not important events.
Small pieces of routines.
Things I’ve done almost automatically for years, for example:
Every night I usually prepare everything I need for the gym the next morning.
Clothes.
Shoes.
Supplements.
Nothing complicated, but lately I’ll prepare the clothes... and forget the shoes. Or prepare everything except the supplements.
Small things, but frequent enough that I started noticing. And then I started seeing the same pattern at work.
I lose the thread
I might have three or four coding agents running at the same time.
One is fixing a bug.
Another is exploring a ticket.
Another is refactoring something.
Another is working in a different application entirely.
While Agent A works, I move to B, while B is thinking, I review C, then A finishes, so I go back to A.
And suddenly:
What was I doing before this?
Sometimes I need a minute, I open the previous ticket, read a few lines. look at the code and then the entire context comes back.
That’s when I started wondering:
Maybe this isn’t a memory problem.
Maybe I’m just constantly dropping context.
Developers already understand this problem
We talk about context all the time. processes have context, requests have context, applications have state, LLMs have context windows.
And humans do too.
When I’m working on a bug, my brain is temporarily holding things like:
- what I’m trying to fix
- what I already tested
- what failed
- what I suspect
- what file matters
- what another service is doing
- what I need to check next
That information may never reach long-term memory, It doesn’t need to. It only needs to stay available long enough for me to finish the task.
That is working memory and working memory is not infinite.
AI changed something important
For most of my career, software development had friction.
You wrote code, you compiled, you waited, you ran tests, you searched documentation, you read Stack Overflow, you tried something. It failed, you stared at the problem, then you tried again, there were pauses. Not necessarily intentional pauses, but pauses.
Now I can do this:
Task A -> Agent A working
Task B -> Agent B working
Task C -> Agent C working
Task D -> Agent D working
Amazing, four things moving at once, except eventually:
Agent A -> finished
Agent B -> needs clarification
Agent C -> changed 12 files
Agent D -> found another problem
And every single one of them comes back to the same place.
Me.
The agents are parallel. I’m not.
This sounds obvious, but I don’t think I fully understood what it meant. AI made execution parallel, it did not make my attention parallel.
Every result still needs a human, someone has to understand it, review it, question it, check the diff, understand the architecture, notice the weird assumption, decide what happens next.
AI reduced the cost of producing work, but it did not remove the cost of:
understanding
evaluating
integrating
deciding
And now there is simply more of that work arriving.
Faster.
Faster output means more decisions
This is where things get strange. Imagine a task used to take me 30 minutes. Now an agent gives me a decent first implementation in 3, I saved 27 minutes.
Great.
So what do I do with those 27 minutes?
I start another task of course - duh!
Then another, then another and suddenly my workflow looks like this:
prompt
switch
review
switch
approve
switch
debug
switch
ask follow-up
switch
read diff
switch
remember what I was doing
The machine got faster, so I made my day more concurrent, and eventually something interesting happens:
I am producing more while feeling less focused.
That feels like a contradiction, it probably isn’t.
Context switching has a cost
We already knew this before AI.
Slack did it.
Email did it.
Meetings did it.
Notifications did it.
But agents make something much easier:
starting more work.
Before AI, opening another task meant I had to actually work on another task, there was a natural cost. Now I can start another workstream with a prompt, thirty seconds later, something else is running in parallel.
The cost of starting work has collapsed, the cost of keeping that work inside my head has not. That changes everything.
Maybe I’m not forgetting
This is probably the part I find most interesting. When I return to something after ten minutes and think:
What was I doing?
the experience feels like forgetting, but then I look at the code.
Read the ticket.
See the previous message.
And suddenly:
Oh, right.
Everything comes back, the memory was probably not gone. The context was simply no longer active.
There’s a big difference between:
losing information and losing access to information because your attention moved somewhere else.
Subjectively, though, they can feel almost identical.
Both feel like:
I forgot.
And yes, life is also happening
I don’t think AI explains everything.
Not even close, stress matters, sleep matters, family matters. mental health matters, changes in routine matter.
Life can leave a lot of invisible processes running in the background.
In my own case, the last few months have contained enough personal stuff that cognitive load is probably already higher than normal.
So saying:
AI is doing this to me
would be lazy. I don’t know that, but I do think AI may be acting as an amplifier. It gives me the ability to create far more cognitive demand than I could create before.
And because that demand looks like productive work... it’s very easy not to recognize it as overload.
Productivity can hide overload
That’s probably what worries me most, overload doesn’t always feel like overload.
Sometimes it looks like this:
- lots of commits
- lots of tickets moving
- lots of agents running
- lots of answers
- lots of progress
Everything appears productive, meanwhile:
attention becomes more fragmented, tasks become harder to reconstruct, small routines start losing pieces, you start rereading things, you switch windows and forget why, you finish the day having done a lot... but feeling strangely scattered.
That’s an interesting failure mode because the dashboard says productivity went up.
We removed almost all the waiting
For decades, engineering has tried to remove latency.
Faster builds.
Faster tests.
Faster computers.
Faster deployments.
Faster feedback.
Faster everything.
That was mostly a good thing, but I’ve started wondering whether some of that waiting had an accidental benefit.
Waiting for a build.
Walking to get coffee.
Reading documentation slowly.
Looking at a bug without immediately asking something else for the answer.
Sitting with a problem. Those moments looked inefficient, but perhaps they gave the brain time to stay inside one context.
AI is removing enormous amounts of friction, which is amazing. But the machine no longer forces us to slow down, maybe that means we need to do it ourselves.
More speed should not mean more concurrency
This is the adjustment I’m experimenting with.
I’m not trying to use less AI. I’m not going back to doing everything manually, that would miss the point.
Instead, I’m trying to separate two resources:
Machine throughput
!=
Human attention
An agent finishing something does not mean I must review it immediately. An agent waiting does not mean I must start another one. A task taking 3 minutes instead of 30 does not mean I need 10 tasks in flight.
The mental model I’m trying to adopt is:
AI works in parallel.
I work sequentially.
The agents can wait.
The output can wait.
The notification can wait.
My attention decides what runs next.
The funny thing is that most agent interfaces still behave like chat applications.
Something happens, they tell you. Another thing happens, they tell you again.
The result is basically:
Agent A -> INTERRUPT
Agent C -> INTERRUPT
Agent B -> INTERRUPT
Agent D -> INTERRUPT
Maybe that is the wrong model, maybe what I actually want is:
11:00 AM
Agent review queue
A: finished
B: blocked
C: needs one decision
D: still working
One review window, one context-switching event. Machines stay asynchronous and humans stay sane. That feels much closer to how agent systems should eventually work.
Developers may just be early
I suspect developers will encounter this problem earlier than most people, simply because coding agents already make extreme parallelism possible.
Today I can have agents:
- writing code
- debugging
- reviewing pull requests
- creating tests
- researching libraries
- exploring architecture
- documenting systems
all at once.
Soon this won’t be unusual, and it won’t be limited to developers.
Managers will have agents, designers will have agents, researchers will have agents, founders will have agents, students will have agents. Knowledge work may become massively parallel, human cognition will not.
There is already a lot of discussion around cognitive offloading.
The concern is understandable.
If AI writes for us, remembers for us, searches for us, reasons for us... maybe we exercise certain cognitive abilities less, but there may be another problem hiding on the opposite side.
Not:
AI makes us think less.
But:
AI makes it possible for us to try thinking about too many things at once.
The chain might look something like this:
More AI
↓
More output
↓
More work in flight
↓
More decisions
↓
More context switching
↓
More fragmented attention
Maybe we’re not becoming forgetful, maybe we’re just overflowing our cognitive context window.
I don’t need to think at machine speed
This may sound obvious too, but I think many of us are unconsciously doing exactly that.
The AI answers faster, so we answer faster. The agent finishes faster, so we start something else faster. Research takes seconds, so we immediately consume more research.
Every efficiency gain creates another opportunity to do something.
And if every second AI saves becomes another task... we haven’t really created free time, we’ve increased throughput. Those are not the same thing.
The next AI bottleneck might be us
It’s still early, agents are new and most people are only starting to build AI deeply into their daily workflows. So I don’t know whether this becomes a serious widespread proble, maybe it doesn’t, but I think it’s worth paying attention to, because eventually one developer won’t be supervising one assistant.
They may be supervising five agents, then ten, then twenty. At some point, the machine will not be the limiting factor anymore. The limiting factor will be the person trying to understand what all those machines just did.
And maybe one of the most important skills in an AI-heavy world will not be learning how to make AI move faster.
It will be learning when not to follow it.
The machines can work at machine speed, we still need to think at human speed.
And maybe that is something worth protecting.
