Python's type system and Kegan's model of human development are both based on paradox, and at least one of them is used to make a lot of free cash flow.

Kegan

Robert Kegan's subject-object theory is a model of how people grow up after they grow up. It splits experience into two buckets:

• Subject: what runs you that you can't see
• Object: what you can step back from, look at, and work with

Growth, in this model of development, is seeing subjects as objects. Not detaching from them, but naming and knowing them.

When you're subject to your eyesight, you just see. When eyesight becomes object, you notice you're wearing contact lenses — and can take them out, clean them, or switch to a different pair. Same world. More options.

type

In Python, every value has a class. Classes themselves are values too — and their class is type.

>>> x = 42
>>> type(x)
<class 'int'>
>>> type(type(x))
<class 'type'>
>>> type(type(type(x)))
<class 'type'>

The tower stops. There is no type1, type2, type3. type is the class of classes, and the class of itself. That self-reference is also how you build new classes at runtime:

>>> Dog = type("Dog", (), {"bark": lambda self: "woof"})
>>> Dog().bark()
'woof'

The same object that is the type system can makes the type system.

Subject

>>> 5
5

Raw value. Raw feeling. You don't have anger because you are anger.

Subject → Object

>>> type(5)
<class 'int'>

Naming the feeling is type(5). You're looking at the shape of the thing, not only being it.

Object does not mean gone. You can still be furious. The difference is there's a handle now: something you can point at, talk about, wait out, reflect on, or text through.

Both Kegan and type are doing the same job: saying what kind of thing something is, so you can operate on it instead of only being operated by it. They build structure. They also mark where structure has to stop.

What happens at the top?

>>> type(type)
<class 'type'>

It doesn't crash. It doesn't invent a higher type. No type2, it just folds on itself: I am structure and I define structure.

Holding your whole self-system as object is that same move. Mind inspecting mind. type inspecting type.

Accepting the paradox

Might sound paradoxical, but some takeaways:

1. The loop is the feature

Once you can see the rules you used to be — your roles, stories, values, the voice that narrates you — the clean split between observer and observed softens. Not because it was fake. Because at the top of the hierarchy, the thing that categorizes is also a category.

Python solved this with a loop, not a taller tower. We can do the same.

2. You can write new classes

type can mint types that didn't exist until you called it. Meta-awareness is the same shape of power: noticing the scripts you inherited (culture, family, "I'm the kind of person who…") without being stuck inside them.

You don't have to delete the old class. You can subclass. You can patch a method. You can ship a Dog that wasn't in the repo this morning.

3. There's no tragedy

Without a self-referential type, Python would need a meta-metaclass, then a meta-meta-metaclass, forever — an infinite tower of "one more level will finally explain it."

People try that move on themselves all the time: I'm thinking about why I'm thinking about why I'm anxious. That's not insight. That's stack overflow with better branding.

It's tempting to treat the top of the hierarchy as a burden — someone has to instantiate types; someone has to author a self. Nah. "Responsibility" is just another object. No tragedy. Just awesome.

Get comfortable with the foundational weirdness. The paradox itself can be object. Cool story bro.

Trust me, everything's gonna be fine.

Once we know the paradox, it's object. It does not rule our dinner party; rather, we invite it and give it a seat.

Yeah, there's a paradox and everything's gonna be fine. Trust me. Lots of companies use Python to generate a lot of free cash flow.

You met me at a very strange time in my life.