FOBO, Grief & Bottlenecks

FOBO & The Five Stages of Grief

Since my last post, the software industry has been cycling through the stages of grief. A tectonic shift is underway. Some remain in denial or anger, rejecting the reality of changing roles. Others are paralyzed by "FOBO"—the Fear of Being Obsolete. Those of us deep in the AI space have reached acceptance. We are now searching for what comes next.

The New Bottlenecks

What We Know Now

Writing code is no longer the bottleneck.
This is the reality for most development work today. It will be universal very soon.

Running systems is next.
If code generation is solved, deployment follows. Creating and managing infrastructure is rapidly automating. Agents are already resolving incidents and spinning up environments.

Agents are moving beyond software.
Claude Cowork marks the first large-scale deployment of agents for general knowledge work. Claude in Excel will give non-developers their first genuine shock regarding AI capabilities. Meanwhile, OpenClaw has surged as an open-source personal assistant, pushing boundaries—safety included—at breakneck speed.

The Historical Pattern

FOBO is understandable, but history offers a counter-narrative: productivity explosions rarely cause mass poverty. Work shifts.

• We don't pick grain by hand.
• We don't mine coal with picks.
• We don't employ rooms of typists.
• We don't use human computers for arithmetic.
• We don't rely on physical mail for correspondence.
• We don't visit libraries for basic research.
• We don't visit record stores to hear music.

We traded repetitive labor for leisure, abundance, and modern infrastructure. Through every automation wave, the human element remains the bottleneck.

The Future of Engineering

The Job Was Never Just Code

Writing software is automated, but the core objective remains: solving problems.

1. Problem: CEO needs revenue.
2. Delegation: Product org defines the solution.
3. Execution: Engineering builds it.

The workflow used to be: Research → Experiment → POC → Build → QA → Launch.
The new workflow is: Research → Experiment → POC → Agent Build → QA → Launch.

The "Build" phase is delegated. The iteration cycle tightens. Capacity per engineer multiplies.

Human Friction

Thorsten Ball recently argued that humans remain the primary bottleneck. Velocity improves by stripping layers between the user and the software. Large companies struggle with innovation not because of tooling, but because of organizational bulk. Each layer adds friction.

We automated secretaries and mailrooms, yet corporations remain complex. Humans instinctively form clans to solve problems. AI will not change this structural reality.

The Hybrid Developer

The developer role will broaden. Specialists will become generalists:

• Product + Fullstack
• Design + Fullstack
• Backend + Infra

Companies will do more with fewer engineers. Alternatively, they will pay the same rate for a developer plus an AI stack, valuing accountability and trust over raw output speed.

Parting Thoughts

The current anxiety stems not from a tangible threat, but from ambiguity. We cannot react to unknown unknowns, so we default to worst-case scenarios. But life goes on. Generations adapt. The human spirit endures.

FOBO & The Five Stages of Grief

The last few weeks have been chaos. The software development world is collectively working through the five stages of grief while a tectonic shift unfolds beneath our feet.

Some developers are still in denial—rejecting the notion that their jobs will change. Others are angry about it. Many have moved into the depression and fear phase, gripped by FOBO (Fear of Being Obsolete). And then there are those of us who've had longer to process the reality and are now asking: what's next?

The Bottlenecks Are Dissolving

Here's what we know now:

Writing code is no longer the bottleneck.

This isn't true for every corner of software development yet—but it will be. Very soon.

Running computer systems won't be the bottleneck either.

Writing code is largely solved. The next step is getting software into users' hands. Infrastructure creation and management is already being automated. Coding agents are handling incident resolution and spinning up environments. The writing is on the wall.

Agents are moving into non-software work.

Claude Cowork represents the first large-scale deployment of AI agents for general office work. Claude in Excel will give non-developers their first real "oh shit" moment with AI. OpenClaw has exploded as one of the fastest-growing open source projects—a personal assistant that's pushing the boundaries of what agents can do, safety be damned.

History Doesn't Repeat, But It Rhymes

There's a lot of FOBO floating around. But time and again, productivity increases haven't led to mass unemployment. People find new things to do. Society doesn't function when everyone is idle.

We don't pick grain by hand anymore. We don't mine coal with picks and shovels. We don't need typists with typewriters. We don't need human computers to crunch numbers. We don't mail correspondence. We don't go to libraries to look up information. We don't buy records at stores.

Instead, we have more leisure time than ever in history, food abundance, modern medicine, air conditioning, running water, heated homes. And we're still the bottleneck.

Writing Software Is Done—But We're Not

Here's the uncomfortable truth: writing software was never the actual job. Developers solve problems.

Problem → Solution
CEO needs a product → Delegates to product org
Product org needs to build → Delegates to product and engineering
Product manager figures out what users want → Works with engineering

Before: Engineering builds product → Engineers research, experiment, build POCs, build software, QA, launch, iterate

After: Engineering builds product → Engineers research, experiment, build POCs, build software (now delegated to agents), QA, launch, iterate

The work is being automated. Iteration cycles are faster and tighter. Productive capacity per engineer increases. That's the shift.

Thorsten Ball recently noted that humans are still the bottleneck—and he's right. For product development, velocity improves when you reduce layers between users and software. We'll see more of this.

But large companies don't lack innovation because of talent. They lack it because of bulk. Layers upon layers of humans create friction. Organizations are complex systems. We used to have pools of secretaries, typists, phone operators, mailroom clerks—ancillary roles that got automated away. Companies are still as large and complex as ever. Humans form clans to solve problems. AI won't change that.

The Work Shifts

Developer work will broaden. Specialists become generalists. Product + fullstack. Design + fullstack. Backend + infra. One person covers more ground.

Companies will do more with fewer developers. Whether that's a good thing or just means paying the same for developer + AI tool as they'd pay for two developers remains to be seen. Sometimes you need someone you can trust and hold accountable. AI might not always win that trade.

The Unknown Is the Scary Part

It's a scary time—not because there's a looming AI threat, but because of ambiguity. We don't know what to expect, so we expect the worst.

But life goes on. Generations come and go. We're still here.

Our human spirit will endure.

FOBO & the 5 Stages of Grief

The last few weeks have been chaotic. The software industry is collectively cycling through the five stages of grief.

Some are still in denial: “This won’t affect me.”
Some are furious: “They’re taking our jobs!”
Many are paralyzed by fear—FOBO, the Fear of Being Obsolete.

I’m past that. I’m in acceptance. Now I’m asking: What’s next?

So what do we know now?

Writing code isn’t the bottleneck anymore.
Not yet for every task—but very soon.

Running computer systems won’t be the bottleneck either.
Infrastructure automation is accelerating. Coding agents are already resolving incidents and provisioning systems.

AI agents are moving beyond software.
Claude Cowork deploys agents for general work.
Claude in Excel delivers an “oh shit” moment for non-developers.
OpenClaw—fastest-growing open-source project—pushes agent boundaries, safety be damned.

This isn’t new. It’s just faster.

Increases in productivity don’t cause mass unemployment. They shift work.

We no longer:

• Pick grain by hand
• Mine coal with picks and shovels
• Hire typists or human computers
• Mail letters or visit libraries for info
• Buy physical records to listen to music

Instead, we have abundance: leisure, healthcare, climate-controlled homes, instant access to knowledge. And we’re still the bottleneck.

Writing software is done. But the job isn’t.

Software development was never about typing code. It was about solving problems:

Problem → Solution

Before: Engineers research, experiment, build POCs, code, QA, launch, iterate.
After: Same flow—except coding is delegated to agents.

Iteration tightens. Velocity rises. Output per engineer increases.

Thorsten Ball notes: Humans remain the bottleneck. We reduce layers between user and software to accelerate delivery. We’ll see more of this.

But large organizations won’t vanish overnight. Bureaucracy persists—not because it’s efficient, but because humans form clans to solve problems. AI won’t erase that.

What shifts?

Specialization fractures. You’ll see broader roles:

• Product + fullstack
• Design + fullstack
• Backend + infra

Companies can do more with fewer engineers. Or—equivalently—pay one engineer + AI tools the same as two humans. In that case, trust and accountability may still beat automation.

Final thought

It’s not the AI that’s scary. It’s the ambiguity. The unknown unknowns.

We don’t know what’s coming. So we imagine the worst.

But history says otherwise. Generations come and go. We adapt. We endure.

We’re still here.
And we’ll still be here—just doing different work.

FOBO & 5 Stages of Grief

The weeks since my last post have seen the software development industry collectively navigating the 5 stages of grief amid ongoing tectonic shifts.

Some are in early grief phases: denying job changes or angry about them. Others face depression and fear tied to FOBO (the Fear of Being Obsolete). Those of us in the AI space, having had more time to process, are in acceptance and seeking next steps.

Bottlenecks

So what do we know now?

Writing code isn’t the bottleneck anymore
This holds for most software development aspects now; it will apply to all soon.

Running computer systems won’t be the bottleneck soon
By "running systems," I mean post-code-writing delivery and management. Infrastructure creation and oversight will soon be automated—coding agents already resolve incidents and spin up infrastructure in my workplace.

Agents are expanding to non-software work

• Claude Cowork: First large-scale general work AI agent deployment
• Claude in Excel: Will trigger non-developers’ first major AI realization
• OpenClaw: Fastest-growing open source personal assistant agent, pushing agent boundaries at safety’s expense

What does this mean?

FOBO is pervasive, but productivity gains rarely lead to mass unemployment or poverty. Work shifts—humans find new problems to solve.

Consider past automations:

• No more hand-picked grain or pick-and-shovel coal mining
• No more typists, human computers, or physical mail correspondence
• No more library information hunts or in-store record purchases

We now have unprecedented leisure time, food abundance, medical care, and basic comforts. Humans remain the bottleneck.

Writing software is done, but we're not done

Writing code wasn’t the real developer job—solving problems was.

Problem-solution chain pre-agent:
CEO needs revenue product → delegate to product org → product org delegates to product/engineering → PM defines user needs → engineering researches, experiments, builds POCs/software, QAs, launches, iterates

Post-agent:
Engineering’s research, experiment, POC, and software-building tasks are delegated to agents. Iteration cycles speed up; per-engineer capacity rises.

Thorsten Ball’s tweet notes humans remain product development’s bottleneck via user-software layer reduction.

Large companies’ bulk (layered organizations) limits radical innovation—past automated roles (secretaries, mail clerks) didn’t simplify company complexity. Humans innately form clans to solve problems; AI won’t change this.

Developer roles will shift to broader stack work (e.g., product+fullstack, design+fullstack). Companies may do more with fewer developers, or pay dev+AI tool the same as two devs (trust/accountability may favor human hires).

Parting words

The scariest part isn’t AI itself—it’s ambiguity and unknown unknowns, which drive worst-case assumptions. Life persists, generations turn over, and human spirit endures.

FOBO & the 5 Stages of Grief

The software industry is collectively navigating the five stages of grief. Some deny impending change. Others rage. Many now dwell in depression, gripped by FOBO—Fear of Being Obsolete. Those of us in AI have processed more, reached acceptance, and search for what comes next.

Bottlenecks

Three shifts are already clear:

• Writing code is no longer the bottleneck. This holds for most development today and will soon be universal.
• Running systems won’t be the bottleneck either. Infrastructure provisioning, incident resolution, and operations are automating. Coding agents handle these tasks now.
• Agents have moved beyond software. Claude Cowork deploys AI for general work. Claude in Excel gives non-developers their first real “oh shit” moment. OpenClaw pushes agent boundaries—safely or not.

What does this mean?

History shows productivity surges don’t cause mass unemployment. Work merely shifts. We no longer hand-harvest grain, pick coal, or employ typists, human computers, or mail clerks. Instead, we gained leisure, abundance, medical advances, and modern comforts. The bottleneck remains human.

Writing software is done, but we're not done.

Developers don’t just write code—we solve problems. AI automates execution: research, experimentation, POCs, coding, QA. Iteration cycles tighten. Product velocity increases by reducing layers between user and software, as Thorsten Ball notes.

Yet large companies remain bulky. Organizational friction—layers of humans for coordination, compliance, scale—persists. Complex systems demand structure. AI won’t collapse these hierarchies; humans will still form clans to solve problems.

Roles will broaden. Specialization in one stack layer gives way to hybrid expertise: product + fullstack, design + fullstack, backend + infra. Companies may do more with fewer engineers. But trust, accountability, and cost parity—paying for a developer plus AI versus two developers—may preserve human roles.

Parting words

The true fear isn’t AI itself. It’s the ambiguity—the unknown unknowns that paralyze reaction. Yet society adapts. Generations endure. Our spirit will too.

FOBO & The 5 Stages of Grief

The last few weeks since my last post have been wild. The software development world has been collectively processing the 5 stages of grief while a tectonic shift in the industry unfolds. Some are still in denial, rejecting that their jobs will change. Others are angry about it. Many are in depression and fear, grappling with "FOBO" or the Fear of Being Obsolete. And then there are those of us working in AI who've had more time to process and are now in acceptance, searching for what's next.

Bottlenecks

So what do we know now?

Writing code isn't the bottleneck anymore

This might not be true for every aspect of software development yet, but it will be very soon.

Running computer systems won't be the bottleneck anymore soon

By running systems, I mean that writing code is solved and the next logical step is getting that software in the hands of people. Creating and managing infrastructure will soon be automated. I'm already seeing people use coding agents at work to help resolve incidents and spin up infrastructure.

Agents are starting to move into non-software work

Claude Cowork is the first large deployment of AI agents for general work.

There's also Claude in Excel which will give non-developers their first real "oh shit" moment with AI.

OpenClaw has caught the world by storm as one of the fastest-growing open-source projects. It's a personal assistant agent that has really pushed the boundaries (at the expense of safety) of what AI agents can do. It's been interesting to watch.

What does this mean?

There's a lot of FOBO out there, but time and time again, increases in productivity don't generally equate to mass unemployment and poverty. People find things to do, and society doesn't really work if everybody is just milling around with nothing to do. This just means that work shifts elsewhere.

We don't still pick grain crops by hand anymore.
We don't mine coal with picks and shovels anymore.
We don't need typists to write memos with typewriters anymore.
We don't need human computers to crunch numbers anymore.
We don't need to mail correspondence to people anymore.
We don't need to go to the library to look up information anymore.
We don't need to go to the store to buy a record to listen to music anymore.

Instead, we now have more leisure time than ever in history, food abundance, medical care, air-conditioning, running water, heated homes—the list goes on and on. And we're still the bottleneck.

Writing software is done, but we're not done.

So back to software. Writing software isn't the bottleneck anymore, but writing software was never really the job. Like most people in an organization, developers solve problems.

Problem → Solution
A CEO needs a product to make money → Delegate problem to product org
The product org needs to build a product → Delegate problem to product and engineering
The product manager figures out what users want → Works with engineering to build it

Before: Engineering builds product → Engineers research, experiment, build POCs, build the software, QA it, launch it, iterate
After: Engineering builds product → Engineers research, experiment, build POCs, build the software (now delegated to agents), QA it, launch it, iterate

What is happening here is that parts of our work are now getting automated. It means that the iteration cycle is faster and tighter, and that our productive capacity per engineer increases.

Thorsten Ball on Twitter just posted a video about how humans are still the bottleneck. How for product development, we can see velocity shifts by reducing the number of layers between a user and the software. I think we'll see more of this to come to some extent.

However, the reason you don't see radical innovation at large companies is just due to their sheer bulk. There are layers upon layers of humans that form an organization, each increasing the amount of friction it takes to navigate through the layers. A lot of those layers are there for good reasons, especially at scale. Organizations are complex systems. We used to have large companies with pools of secretaries, typists, phone operators, mailroom clerks, etc. Many ancillary roles that were eventually automated away, yet companies are still as large and complex as ever. Humans have an innate need to form clans to solve problems. I don't think AI will change this.

I think ultimately the work of a developer will shift towards broader work, working across more of the stack where people were once specialized in an area. Now they might specialize in multiple—for example, product + fullstack, or design + fullstack, or backend + infra. This also means that companies will be able to do more with fewer developers, which might be a good thing, or it might just mean they'd be paying the same for developer + AI tool as they would for 2 developers. In that case, AI might not necessarily win out over having somebody you can trust and that's accountable working for you.

Parting words

It's a scary time, but not because there is an actual looming threat of AI. The ambiguity of the situation, the unknown unknowns is what's scariest. We don't know what to expect so we can't react, so we expect the absolute worst. But life goes on, generations come and go, we're still here, and I believe that our human spirit will endure.

FOBO & the Five Stages of Grief in Software Development

The software industry is moving through the classic five stages of grief. Rejection, anger, bargaining, depression, and now acceptance dominate conversations as tectonic shifts reshape work. While some teams still deny that their roles will change, others wrestle with FOBO—the Fear of Being Obsolete. Those in AI already see the pattern: the bottleneck is no longer code.

Bottlenecks

Writing code isn’t the bottleneck anymore

Automation will soon handle most code generation. Agents already resolve incidents and spin up infrastructure. The remaining manual work is limited to domain‑specific constraints and strategic oversight.

Running computer systems won’t be the bottleneck soon

Infrastructure provisioning, orchestration, and monitoring are being automated. Coding agents are already used in production to manage cloud resources, reducing human effort in deployment pipelines.

Agents are entering non‑software work

• Claude Cowork – a large‑scale deployment of AI agents for general office tasks.
• Claude in Excel – AI assistance for finance professionals, delivering the first “oh‑shit” moment for non‑developers.
• OpenClaw – an open‑source personal assistant agent that pushes the limits (and safety concerns) of autonomous agents.

What This Means

FOBO spreads, but productivity gains historically do not translate into mass unemployment. Society adapts: we no longer pick grain by hand, mine coal with shovels, type memos on typewriters, crunch numbers manually, mail letters, or visit libraries for information. Leisure time, food abundance, healthcare, and utilities have expanded, yet humans remain the bottleneck.

Writing Software Is Done, but We Aren’t

Problem → Solution has always been the developer’s job. The chain now looks like:

1. CEO needs a revenue‑generating product → delegates to product org.
2. Product org needs a build → delegates to product + engineering.
3. Product manager defines user needs → works with engineering.

Before: engineers performed research, experiments, POCs, coding, QA, launch, and iteration.
After: research, experiments, POCs, coding (delegated to agents), QA, launch, and iteration.

Automation tightens iteration cycles, increasing each engineer’s productive capacity. Thorsten Ball’s recent tweet on humans as the bottleneck underscores this: fewer layers between user and software yield higher velocity.

Large firms retain their bulk because each added human layer introduces friction, often necessary at scale. AI will not eliminate the need for trusted, accountable collaborators.

Parting Words

The uncertainty—not AI itself—is the source of fear. Unknown unknowns dominate the narrative, prompting worst‑case assumptions. Yet history shows human ingenuity persists. As generations evolve, so will our capacity to define and solve problems. The spirit endures.

The 5 Stages of FOBO: What Happens When Writing Code Isn’t the Bottleneck Anymore

The software industry is in the throes of collective grief. Some are still in denial, others rage against the inevitable, and a few—like those of us embedded in AI—have reached acceptance. The tectonic shift isn’t coming. It’s here.

The Bottleneck Has Moved

What We Know Now

1. Writing code is no longer the bottleneck.

   • For most of software development, this is already true. For the rest, it will be soon.

2. Running systems won’t be the bottleneck for long.

   • Infrastructure—spinning up environments, resolving incidents, managing deployments—is being automated. AI agents are already handling these tasks in production.

3. Agents are escaping the codebase.

   • Claude Cowork is the first major deployment of AI agents for general work.
   • Claude in Excel will give non-developers their first oh shit moment with AI.
   • OpenClaw is pushing boundaries (and safety limits) with personal assistant agents, proving what’s possible.

FOBO Is Real, But History Suggests We’ll Adapt

Fear of being obsolete (FOBO) is understandable. But productivity gains rarely lead to mass unemployment. Instead, work shifts.

We no longer:

• Pick grain by hand.
• Mine coal with picks and shovels.
• Type memos on typewriters.
• Crunch numbers as "human computers."
• Mail letters or visit libraries for information.
• Buy physical records to listen to music.

Instead, we have:

• More leisure time than ever.
• Food abundance.
• Advanced medicine.
• Air conditioning, running water, heated homes.

The bottleneck remains human. AI doesn’t eliminate the need for problem-solving—it just changes how we solve problems.

Software Development After the Shift

Writing software was never the real job. Engineers solve problems. The process has always been:

Problem → Solution

• CEO needs revenue → Product org builds it.
• Product org needs features → Engineering delivers them.
• PM defines requirements → Engineering executes.

Before AI:
Engineers researched, built POCs, coded, tested, launched, iterated.

After AI:
Engineers research, experiment, build POCs (now delegated to agents), test, launch, iterate.

What Changes?

• Faster iteration cycles. Less time spent on repetitive tasks.
• Higher productivity per engineer. More output with fewer people.
• Broader roles. Specialization narrows—full-stack + product, design + backend, infra + DevOps.

Why Big Companies Move Slowly

Large organizations are slow not because of AI, but because of layers of friction. Companies used to employ secretaries, typists, mailroom clerks—roles that vanished, yet organizations remained just as complex.

AI won’t eliminate the need for human problem-solving. It will just change who does it and how.

The Future Isn’t Obsolete—It’s Uncertain

The fear isn’t AI itself. It’s the unknown. We don’t know what comes next, so we assume the worst.

But history repeats: We adapt. Generations rise and fall. Society finds new ways to thrive.

The human spirit endures. The question isn’t whether we’ll survive this shift—it’s what we’ll build next.