The company itself grew up around a bottleneck

His first justification for the list reaches back much further than AI: organizations shape technology, and technology shapes organizations right back. Double-entry bookkeeping, the printing press, the steam engine, the fax machine, the last thirty years of internet and software — each one redefined what it meant to run an organization well. AI will be next.

First, answer an older question: why does the company exist at all?

1937, a question almost nobody asked

That year, economist Ronald Coase asked: if markets are so efficient, why isn't everything handled through one-off contracts, priced and negotiated deal by deal?

His answer: negotiating itself costs money. Finding the right person costs money. Bargaining over price costs money. Coordinating costs money. Verifying afterward that the other side actually delivered costs money. When those costs are lower inside an organization than out in the market, the activity gets absorbed into that organization. That's how companies came to exist.

Adam Smith's pin factory supplies the other half of the same story. Once making a pin gets broken into separate steps, a job appears that never existed before: stitching the split-up work back together. Coordination is free when it all lives in one person's head. Split the labor, and coordination becomes a cost — and eventually a profession, called management.

Read this way, a company's substance is its coordination friction. Friction isn't a flaw in the company. Friction is the company.

Most of what knowledge workers do all day belongs to that layer of friction. The Slack message to a coworker, the meeting called to lock in a decision, the notes written up after a customer call, the report pulled from Salesforce — none of that is the work itself. None of it exists when a single person is working alone.

Strip that friction away, and you haven't made your employees a bit more capable. You've changed what a company is. Jeff Huber, "The quick shall inherit the earth," June 15, 2026

When technology moves the bottleneck, the company gets rebuilt around it

Ford is the example everyone reaches for. Mass-manufacturing technology existed before him; he simply took the assembly line more seriously than his contemporaries and rebuilt the entire business around it. Chassis assembly dropped from twelve and a half hours to ninety-three minutes. The Model T's price fell from $850 in 1908 to $260 in 1925. Worker pay rose to $5 a day — double the industry standard. Competitors who couldn't keep pace lost on price, lost on wages, and most didn't survive in their old form.

But the lesson here isn't about cutting costs and boosting efficiency. What Ford actually did was reorganize the entire company around a new bottleneck.

The same held when paper processes gave way to enterprise software. Larry Ellison's pitch deliberately skipped past "encode your current process a bit faster." What he actually said was: stop describing how this company has run for the last twenty years, and figure out how it should run for the next twenty. Companies that took that seriously rebuilt themselves around the software. Companies that just digitized their old process ended up with a faster old company — and lost.

Coase, Adam Smith's pin factory, the Ford figures, and the Larry Ellison passage all come from Huber's earlier piece "The quick shall inherit the earth" (June 15, 2026), not from this 12-rule list. Figures are cited as they appear in his original.

He believes the bottleneck has already moved

Companies used to be designed around the bottleneck of "how fast people execute." But if execution has become largely commoditized, then context (a company's entire body of knowledge, written down or not), know-how, secrets, and taste start to be what's valuable. The bottleneck has moved to people's taste and judgment.

When the bottleneck moves, what the company packages moves with it

His earlier piece named this mechanism "disaggregation theory": AI breaks execution apart while re-concentrating power around context, data, trust, permissions, and governance.

The old company packaged labor and coordination. The new company packages context and authorization. All twelve rules grow out of that one sentence.

The original sorts the twelve rules into six pairs — the first two are trade-offs (hold your data tight, let go of compute; build your own tools, buy your infrastructure outright), and the remaining four pairs are just two moves under one theme. Re-sorting by what each rule points at: seven are about accumulating context, four are about handing off execution, and two are left for what only people can do. The full twelve are listed at the end; first, the essentials from each of these three groups.

Rule one: your data has to actually be yours — including what AI derives from it

This is the most forcefully worded rule in the whole piece. Translated into a purchasing decision, the test is one sentence: a vendor either gives you complete, unrestricted access to your data — including anything derived from it — to use however you want, or you should be looking at a different vendor. Steer clear of any tool trying to hoard your data to build its own moat.

Rule one also carries a requirement that's brutal to execute. Your context isn't just what's written down — it's everything in the company's experience and habits that never got written down at all. To make the company legible to both people and Agents, that knowledge has to be written down for the first time.

Human organizations have existed for millennia, and this kind of knowledge has always spread through mentorship, tenure, and being physically present — never under any pressure to be fully captured in writing. And the task is hard on its own terms: this is called tacit knowledge precisely because, as Michael Polanyi — who coined the term — put it, "we know more than we can tell."

Rules three and four: build your own tools, buy your foundation

Building software has never been this cheap or this easy, and the line between buying and building is sliding toward "build." The tools you use are fused to the specifics of your business — owning them outright is another way of protecting that unique context.

But that doesn't mean building everything yourself. He adds a parenthetical here: you (probably) shouldn't build your own serverless training infrastructure, database, or operating system. The strongest reason to buy those — beyond moving faster and having a more stable system — is that it frees you up to build more unique context elsewhere.

New work shows up? Teach an Agent first. Hire only if it can't learn.

Rule five, he says, is simple enough to state in one line: when a new task comes in — say, screening job applicants — first try teaching an Agent to do it, and only then consider hiring a person for it.

The order has flipped. It used to be: figure out who should do this work, decide whether you need one more hire. Now step one is: figure out whether you need that hire at all.

Rule six is about the team: keep it small, and keep taste extremely high. Small, high-quality teams decide faster and trust each other more. Since the bottleneck has moved from execution to taste, staff around the new bottleneck.

Rule seven: information defaults to open — but there's a catch

The old company sliced information into pieces and let each piece stake its own territory. Huber thinks that never worked especially well even in the past, but today it's catastrophic, because an Agent's competence depends entirely on what context it can actually get.

He attaches a qualifier to this rule: default to open is aimed at your small, high-quality team. This rule pairs directly with the one before it — if your team isn't small and isn't sharp, throwing every piece of information open indiscriminately isn't necessarily a good thing.

The last five rules are about making the Agent right more often

Rule eight sets the direction: the organization that wins is the one that climbs the mountain of "serve customers and the market well" faster — in other words, learns faster. So design the company as a machine that never stops learning, and compress the cycle time of each learning loop as much as possible.

The remaining four rules are the parts of that machine.

Rule nine: give it instructions, and a scorecard

For core and mission-critical tasks, beyond detailed instructions, give the Agent a scorecard it can grade its own output against. That scorecard — and every criterion on it — should itself keep getting revised.

Rule ten: don't just leave it waiting for assignments

There's an easy trap here: treating the Agent like a junior intern — hand it a task, it does the task, and with luck it does it well. That works, sure. But the coworkers people actually enjoy working with are the ones who show initiative — who are constantly thinking about the business, the customers, the roadmap, and proactively suggesting improvements. So build background Agents with enough organizational context to do exactly that.

Rules eleven and twelve: keep the record, then fold your judgment back in

Rule eleven: keep a record of every real execution. He stresses this one is subtler than it looks. Buying a pile of monitoring tools just in case isn't the point. The point is to use the Agent's actual execution history to make the Agent itself better.

He says this isn't quite "recursive self-improvement" yet (AI improving itself, getting stronger with each pass) — but for people building AI applications, it's not far off either.

Rule twelve: encode your own expertise into the system. The highest-leverage move for making an Agent better is finding the patterns in its recurring mistakes and correcting them. And this itself can be delegated: other Agents you run can probably spot those patterns, then come back and interview you to help fix them.

The extra rule he added himself

After the twelve, he adds one more, labeled bonus:

Above all: think first, then AI. Your thinking and your taste are — and will remain — your edge. Jeff Huber, "12 factor companies," July 20, 2026

Near the close he writes: organizations that follow this will be smaller, faster, and deliver far more value to customers than their size would suggest. Organizations that don't will die.

This list ships with no supporting data at all — it's one person's judgment and reasoning, start to finish.

All twelve rules, to check against your own company

Below are all twelve rules plus the bonus, each with a plain-language gloss. Check off the ones you're already doing.

The twelve rules are translated as worded in the original; qualifiers in parentheses (like "probably" in rule 4, or "small, high-quality team" in rule 7) are the original author's own hedges, kept intact here. The plain-language gloss after each rule is this site's own paraphrase.

On July 20, 2026, Jeff Huber — Chroma's co-founder and CEO — wrote 12 rules (Chroma is an open-source AI retrieval database that helps AI applications store and query material). The format is borrowed: Adam Wiggins used it in 2011 to describe how a program should be written; Dex Horthy used it in 2025 to describe how an Agent (a self-directed AI program) should be built. This time it governs an entire company.

His premise: execution is becoming cheap, so what a company packages has to change — from labor and coordination, to context (a company's entire body of knowledge, including whatever only lives in a veteran employee's head) and authorization.

Which raises the next problem: most of that knowledge was never written down to begin with — so what should the company be rebuilt around now?

The whole list rests on one line: the bottleneck hasn't disappeared, it changed location. One concrete task makes this clearest.

• Accumulating context (7 rules): data must belong to you completely and unrestrictedly — including what AI derives from your data. If a vendor won't do that, switch — he calls these tools "context vampires." One rule is especially brutal: veteran employees' unwritten experience has to be captured in writing for the first time, so the company becomes legible to people and Agents alike.
• Handing off execution (4 rules): new work shows up — say, screening resumes — try teaching an Agent to do it first, hire only if it can't learn. Give it instructions plus a scorecard to self-check against, keep a full record of every real execution, and feed its recurring mistakes back into its instructions.
• What's left for people: keep the team small and taste high; default internal information to open — and that line is aimed specifically at that small, sharp team.

This list ships with zero supporting data. The hardest evidence Huber can point to for a bottleneck actually shifting is Ford, a century ago. Same task: assembling a car's chassis.