Abstraction

There’s a firm.

A massive consulting firm.

Let’s just say it’s one of those.

The kind that has offices in 100 countries.

Departments stacked like floors on a skyscraper.

Thousands of employees.

Billions in revenue.

And somehow, it doesn’t fall apart.

That’s what I can’t wrap my head around.

Many of its departments aren’t just different.

They’re opposites.

One department takes on a client.

Suddenly, another department is not allowed to interact with them.

Firewalls.

Chinese walls.

Security protocols.

Internal boundaries stricter than divorcees with bad fallout.

And yet…

The whole thing works.

Like clockwork.

No single human being knows the whole structure.

Even someone who’s been there for a decade won’t know all of what’s going on.

It’s not that they’re lazy.

It’s just that big.

And still, somehow, the machine keeps humming.

Here’s the part that breaks my brain.

This giant, this skyscraper of process and policy…

Is still run by humans.

Humans.

If you removed the people, it would collapse overnight.

Because what this firm really sells isn’t consulting.

It’s human brains for hire.

And yet

Even the humans operating it don’t fully understand the thing they’re operating.

How?

That’s the marvel.

It’s like watching ants build a colony that’s smarter than any one ant.

But this isn’t normal.

This is bureaucracy.

Compliance.

Abstraction.


People make fun of bureaucracy.

They think it’s pointless paperwork.

But what if bureaucracy isn’t the enemy of action,

But the engine behind scale?

What if bureaucracy is what turns chaos into ritual?

At this firm, you fill out timesheets.

You log hours.

You track code.

You archive files.

You do all the things that seem… detached from the real work.

But it’s those invisible rituals that keep the form intact.

Without them, it’s just a bunch of brains walking around, stepping on each other.

So yes, bureaucracy slows you down.

But maybe it’s the only reason the machine doesn’t eat itself.


This all reminds me of something else.

The paradox of simplicity.

A man can tear a paper with his hands.

Easy, right?

Now build a machine to do it a thousand times a minute.

You’ve just added layers of gears, blades, cooling, sensors, wiring…

You created complexity just to achieve simplicity at scale.

That’s the trick.

Simplicity on the front.

Complexity at the back.

Hidden machinery.

And now, back to the firm.

It runs the same way.

Behind every action, there’s a thousand invisible cogs.

Bureaucracy for the human side.

Automation for the machine side.

Both are doing the same thing:

Creating abstraction.

Turning action into process.

Turning process into system.

So the work can happen without you needing to understand it.


And maybe that’s the strangest bit of all.

We built systems we don’t understand.

And then we put humans inside them.

Humans who also don’t understand them.

But it still works.

Why?

Because the abstraction runs deeper than comprehension.

It runs on trust.

On templates.

On “this is how we do it.”

On “don’t worry, just follow the form.”

Maybe the system doesn’t care if you understand it.

It just needs you to play your part.

Maybe the goal was never intelligence.

It was continuity.

And maybe, just maybe

That’s how the world works.

Not because we understand it.

But because we designed it so we wouldn’t have to.

But what is abstraction, really?

It’s not about simplifying.

It’s about building a machine that runs on its own.

In human systems, it’s bureaucracy—timesheets, logs, protocols.

In non-human systems, it’s automation—code, triggers, workflows.

Both do the same thing:

They remove the need for intervention.

Abstraction creates an enigma.

One that doesn’t pause for permission.

One that doesn’t care if you understand it.

You build the frame.

You set the logic.

Then it runs—cold, repeatable, intact.

That’s the power.

Not that we get it.

But that it keeps going—even when we don’t.

So where does that leave you?

You’re inside a system you don’t fully control.

Most of your job is navigating layers someone else built.

Forms you didn’t invent.

Processes you follow blindly.

Decisions made long before you arrived.

You’re not failing.

You’re just swimming in someone else’s abstraction.

The question is—can you build your own?

So how do you build your own?

Not by working harder.

But by rising a level up.

Start with one layer.

One routine you don’t want to repeat.

One decision you don’t want to keep making.

Turn it into a rule.

Wrap it in a structure.

Let it run without you.

You write the same email every week?

Make it a template.

Automate the trigger.

Forget it exists.

That’s a layer.

Now do it again.

And again.

Until your presence becomes optional

But the output keeps showing up.

Delegation.

Bureaucracy.

Automation.

None of them are fun.

Not fun to do.

Not fun to manage.

Not fun to sit through.

Definitely not fun to be a subject of.

But they’re the only things that scale without you.

And if you’re running your own venture,

They’re the difference between being busy

And being rich.