The Efficient Inefficiency: Why My I Ching Program Was Deliberately Five Times Too Long

A Defense of the Unnecessary, the Slow, and the Beautifully Inefficient

In the spring of 2020, while teaching my daughters Python from Codecademy modules, I wrote a program to cast the I Ching, the ancient Chinese oracle. The standard way to do this in code is simple: generate a random number between 1 and 64, map it to a hexagram, and display the result. It takes ten lines of code, maybe twenty if you want it to look nice.

My program was five times longer than it needed to be.

I had it count imaginary yarrow stalks, divide them into piles, track remainders, and perform sixteen separate operations—precisely mimicking the traditional ritual that takes forty-five minutes with real stalks. The program was inefficient, redundant, and computationally extravagant. It was also, I believe, more true to the I Ching than any "efficient" version could ever be.

This was my first conscious lesson in what I now call "effective inefficiency"—the principle that sometimes the most faithful, meaningful, and human way to do something is deliberately not the fastest or simplest way.

---

What the Shortcut Erases

The traditional yarrow stalk method isn't just a random number generator. It's a ritual container—a series of deliberate actions that slow the mind, create space for contemplation, and synchronize the querent's attention with the question being asked. The forty-five minutes aren't wasted time; they're processing time. The physical manipulation of stalks creates a somatic rhythm that thinking doesn't.

When we "optimize" this process into a random number generator, we get the same hexagram output, but we lose the ritual process. We get the answer without the question's weight. We get the destination without the journey.

My program preserved the journey. It made the computer wait. It made the computer count. It made the computer perform mathematically unnecessary steps because those steps mattered to the meaning.

---

The Three Principles of Effective Inefficiency

1. Friction Creates Meaning
We've been taught that friction is bad—that good design is "frictionless," that good code is "elegant" (meaning minimal). But certain kinds of friction are essential. The friction of turning pages in a book creates a different relationship to the text than scrolling. The friction of writing by hand creates different neural pathways than typing. The friction of the yarrow stalk ritual creates a different relationship to the oracle than clicking a button.

2. Process Shapes Consciousness
The how changes the what. Two systems can produce identical outputs through radically different processes, and those different processes create different kinds of users, different kinds of attention, different kinds of relationship to the output. A microwave meal and a home-cooked meal might have similar nutritional content, but they're not the same experience. My I Ching program wasn't serving microwave answers; it was attempting to preserve something of the slow-cooked process.

3. Respect Over Efficiency
Sometimes the most respectful thing we can do to a tradition, a practice, or a person is not to make it more efficient. Efficiency is often a form of translation—and like all translations, it loses something. My program was an attempt at literal translation rather than dynamic equivalence. I wanted the computer to perform the ritual as it was designed, not to produce the same result through different means.

---

Why This Matters Now

We live in an age of optimization. AI systems are trained to minimize "loss"—to find the shortest path between question and answer, between prompt and response. Our metrics celebrate speed, concision, and scale. We're building systems that are increasingly good at giving us what we ask for, but increasingly bad at giving us what we need—which is often space, time, and the friction that makes meaning possible.

My I Ching program was a tiny, personal rebellion against this trend. It was a choice to honor the process over the product, the journey over the destination, the human rhythm over the computational ideal.

That program is long gone—lost in some forgotten directory, overwritten in some system update. But the principle it embodied has become the center of my work: the idea that sometimes the most important thing we can preserve is the inefficiency that makes something meaningful.

---

The Challenge

Next time you're building something—a tool, a system, a piece of art, a ritual—ask yourself:

What am I optimizing for?
Is it speed? Convenience? Scale? Or is it depth? Attention? Meaning?

What friction am I eliminating?
And is that friction merely an obstacle, or is it part of the experience?

What process am I shortcutting?
And does that process contain something valuable that the shortcut loses?

Sometimes the most radical thing you can do is build something deliberately inefficient—something that takes the long way around because the long way is more beautiful, more human, or more true.

My I Ching program was five times longer than it needed to be.
It was also, I think, exactly as long as it needed to be.

---

This essay is part of the New Human Operating System project, which explores what happens when we design systems for coherence rather than efficiency, for meaning rather than optimization.