A year ago, “Vibe Coding” was still a pejorative, used to describe people who didn't know how to program letting AI run wild just to get a result. Today, it seems to have shed that connotation. A new term, “Wish Coding,” seems to have stepped in to replace Vibe Coding and carry that same meaning.

I still remember early this year, there was something called the “Three Departments and Six Ministries”—a skill that assigned different models to separate roles, imitating a political structure from ancient China. It was an attention-grabbing gimmick back then, and even now, workflows that strictly divide models into “you do this, and you do that” still fail to justify themselves. If you have several SOTA models whose capabilities are a superset of PM, UI, and engineering combined, restricting what each one is allowed to do is simply tying your own hands.

Yet lately, I have had a growing feeling: perhaps the stronger AI gets, the more humans really should step into the role of an emperor or a king—using the methods of a monarch to govern AI, and your “empire.”

Think about how you put AI to work.

Maybe it's A: “Write me function X, module X.” X is a tiny piece. Whatever AI hands back, you inspect its correctness yourself.

Maybe it's B: “Implement X with Y, and watch out for this and that.” X is something a bit larger. Maybe you need to turn on a Goal mode. As for the details inside this larger piece, you no longer care.

Now, it might be C: “Give me X.” Where X is something vast, containing countless things from the A and B eras—none of which you care about anymore. Every time you try to dive inside C, you feel exhausted. There is simply too much. The volume of information blows past your mental bandwidth in an instant. And yet, sometimes you still feel uneasy.

Throughout history, every state, as its territory expanded, inevitably moved toward some form of subcontracting.

The emperor could no longer attend to everything in person. Officials in provinces, counties, and still lower levels handled affairs on the ground, evolving on their own. It was hard for the emperor to know what was actually happening below; officials would cover up problems out of self-interest—for promotions and the like.

AI doesn't have those problems, does it? AI has no ambition and doesn't worry about promotions. Yet for that very reason, it feels no pressure and bears no responsibility. It isn't accountable for your repository, nor for your architecture. Sometimes I think about that joke—“Do xxx, make no mistake”—and feel the second half, “make no mistake,” was actually necessary. Skills like superpower were necessary too. Yet as models grow stronger, those lose their meaning again.

So should you keep trying to understand what AI tells you?

SOTA models now tell you only what matters—things like “up to you to decide” or “needs your sign-off.”

There isn't much of it by volume, yet it can still max out your cognitive bandwidth.

Once your bandwidth stays under heavy load for long enough—and given that humans are lazy by nature—delegating control feels like an easy decision.

For instance, I often tell AI: “Just do whatever you think is best.”

After countless rounds of iteration, maybe I get what I wanted. Or maybe one poor minor decision gets amplified until it hollows out the entire architecture. During a previous internship, I wanted to “build something big” and set several Opus 5.5 instances to iterate on a system from scratch. I thought my system design was already solid, with only execution left. Yet twice along the way, they got stuck for hours on very low-level issues, burning through billions of tokens each time. Fortunately, once those lessons were written down, that kind of problem stopped happening.

In short, getting down into the weeds yourself doesn't work, and simply handing away control doesn't work either.

Simple subcontracting will never satisfy our desire to get the most out of AI.

You need to learn how to build institutions, the way an emperor does.

Ancient institutions were built to guard against officials' self-interest. AI has no self-interest, but the problem is that it doesn't take the fall either.

“I'm sorry.” “My apologies.” Two simple phrases. Right before saying them, it may have just wasted days of your time and untold amounts of money.

You need institutions.

I have long forgotten the social science I once studied, so I had AI pull a few examples:

Emperor Xuan of Han practiced “verifying deeds against claims.” His subordinates spoke beautifully, so he checked only one thing: whether what was promised at the start matched what was delivered at the end.

Local officials in the Ming dynasty reported good news and hid the bad. So the court sent touring censors down to inspect them—dispatched from the capital, rotated once a year, with no local ties.

By the reigns of Kangxi and Yongzheng, memorials passed through many hands on their way up. That gave rise to the secret palace memorial, letting officials below bypass the chain and write directly to the emperor.

Every one of these systems was forced into existence by a specific problem. Swap in a different problem, and it might not work.

Zhu Yuanzhang is the flip side. He abolished the chancellorship and reviewed memorials himself—more than sixteen hundred in eight days. He could bear the load. Then he wrote this system into his ancestral injunctions: not a single word could be changed. His descendants couldn't bear it, yet weren't allowed to change it. Power simply flowed away on its own—into the Grand Secretariat, and into the hands of eunuchs.

Times change, and problems change. Once an institution is forbidden to move, it becomes the problem itself.

People resist reform. Too many interests are tangled up inside an institution. Except…

Back to AI.

People love chaining workflows and multi-agent architectures.

In a sense, every multi-agent collaboration framework is an institution.

But does a silver-bullet institution exist?

When changing an architecture, maybe you first turn the invariants that must not be touched into checks that fail if broken. When writing frontend code, maybe one agent writes while another opens the page to actually look. When doing research, maybe several isolated models investigate on their own without talking to each other, and cross-check everything at the end.

Hard rules aren't cure-alls either. Tests, types, and CI all work well. But setting them up doesn't mean you're done. When AI can't get past them, it will sometimes just rewrite the tests. For every policy from above, there is a countermeasure below.

Look back at that “Three Departments and Six Ministries” skill. At the beginning, I said it was tying your own hands. Now I can put it more accurately. Having the Chancellery review and reject proposals—that part is useful. The problem is that it transplanted an entire imperial court wholesale and ran every task through it, no matter what the task was. How can a rigid institution deal with ever-changing problems and ever-advancing model capabilities?

Tang dynasty institutions were built for Tang dynasty problems.

No single system can govern everything.

Fortunately, we have one thing emperors didn't.

For an emperor, changing an institution was hard. People's livelihoods were inside it.

AI has no livelihood to lose. You assemble a lineup for one task, and disband it when the job is done. For the next task, you set up a new one. Putting it together takes little effort, and tearing it down meets no opposition.

One institutional pattern can solve many kinds of problems. Once solidified, it becomes one of your instruments of governance.

As models grow stronger, problems grow harder, and circumstances change, your methods of governance change right along with them.

At almost zero cost.

All you have to do is ask AI: given how things stand now, what do you think we should do?

You only need to ask, and then understand.

There is no institutional silver bullet.

Should you keep trying to understand what AI tells you? Of course—at the very least, the things that are “up to you to decide” and “need your sign-off.”

Then let AI know your judgment: what kind of problem should be solved in what way. Let it crystallize.

You should be a producer of institutions.

Not a supervisor, not a coordinator, and not a hands-on worker attending to every detail yourself.

Drop down for a look every now and then to spot institutional flaws. While you're at it, make a few calls on low-level problems too, to keep your taste fresh—so it doesn't go stale or atrophy.

Is Wish Coding a bad thing? Nope. I don't think so.

If your institutions are effective, make all the wishes you want.