Skip to content

My 16 Bits

The Return of the 32K Ghost

There is something wonderfully, darkly comic about the fact that in 2026—an era in which we train trillion-parameter models, simulate protein folding, and ask machines to hallucinate legal arguments with supreme confidence—we are once again being told:

“Sorry, your input is too long.”

Not philosophically too long.
Not aesthetically indulgent.
But numerically unacceptable.

If you were around computers in the 1990s, this should feel eerily familiar. Like bumping into an old acquaintance in an airport bar who looks exactly the same and still owes you money.

The 32-kilobyte limit—once the calling card of Win16 text boxes and earnest GUI toolkits—has staged a quiet comeback. This time wearing a Patagonia gilet and calling itself context length.

The tyranny of convenient numbers

The original 32K limit was not designed. It emerged.

It came from a perfect storm of:

  • 16-bit signed integers
  • Cursor positions stored as short
  • The charming belief that “no one would ever need more text than this”

In other words, it wasn’t ideology. It was accounting.

And now, decades later, we are doing exactly the same thing—only with embeddings, tokenizers, and attention windows.

The modern equivalent is not:

“Documents should be short”

but:

“We need a number that keeps inference fast, predictable, and cheap.”

So we pick one.

8k tokens.
16k tokens.
32k tokens.

Lovely round numbers. Deeply reassuring. Entirely arbitrary.

AI didn’t resurrect the limit — it rebranded it

What’s fascinating is that AI didn’t inherit the limit from old systems. It reinvented it for the same reasons, which is much more embarrassing.

The constraint now comes from:

  • Quadratic attention costs
  • GPU memory ceilings
  • Latency expectations disguised as “UX”

But the experience is identical.

You paste in something big and meaningful—perhaps a real document, written by a human, with history and context—and the system responds with the digital equivalent of a Victorian footman:

“I’m terribly sorry, sir, but that is quite beyond what we were expecting.”

This is how you know we haven’t escaped the past. We’ve merely wrapped it in better metaphors.

Context is the new clipboard

In the 90s, the clipboard was the choke point.

You could write a long document.
You could store a long document.
But try to move it between systems and—bang—hard stop.

Today, context is the clipboard.

AI systems are astonishingly capable at:

  • Generating text
  • Transforming text
  • Summarising text

But strangely fragile when asked to:

“Hold this entire thing in your head for a moment.”

Which is ironic, because holding context is literally the thing we describe them as doing.

Why this matters more than it seems

Limits don’t just constrain behaviour. They reshape it.

Just as 32K limits trained people to:

  • Split documents unnaturally
  • Abuse file formats
  • Invent baroque workarounds

AI context limits are now teaching people to:

  • Over-summarise too early
  • Strip nuance for token efficiency
  • Optimise for model digestion rather than human meaning

We are, once again, designing for the system instead of for ourselves.

And as before, we will pretend this is good discipline.

(It wasn’t then. It isn’t now.)

The real danger: premature compression

The most damaging thing about hard limits isn’t that they block expression.

It’s that they encourage early loss.

Once you summarise something to fit a window:

  • The discarded details are gone
  • The framing hardens
  • The narrative ossifies

This is exactly what happened with early document systems: structure calcified around constraints that had nothing to do with comprehension and everything to do with implementation convenience.

AI is now doing the same thing—only faster, and at planetary scale.

The punchline

The 32K limit never died.

It simply waited patiently for us to invent systems complex enough that we’d once again say:

“Surely no one will ever need more than this.”

And just like last time, we’re wrong—not because humans have changed, but because meaning doesn’t compress cleanly, no matter how clever your math is.

The lesson from the 90s wasn’t “make limits bigger.”

It was:

Beware of constraints that feel technical but behave psychological.

Because once a number sneaks into the interface, it stops being an implementation detail and starts becoming a belief.

And beliefs, unlike integers, don’t overflow gracefully.