Run Your Marketing Like a Nuclear Submarine: What L. David Marquet Taught Us About Building AI That Leads

When people imagine AI transforming how B2B companies do marketing, they usually picture one of two extremes. Either the AI is a brilliant intern — eager, fast, and utterly dependent on being told what to do next — or it's a black-box autopilot you switch on and nervously hope for the best. Both pictures are wrong, and the reason they're wrong was worked out decades ago, a hundred meters underwater, by a submarine captain who never intended to write a management book.

The captain was L. David Marquet, and the book he eventually wrote — Turn the Ship Around! A True Story of Turning Followers into Leaders — has become one of the most quietly influential leadership texts of the last twenty years. It's the story of how Marquet took command of the USS Santa Fe, then the worst-performing submarine in the US Navy's Pacific Fleet, and within a year turned it into the best — not by becoming a better commander in the traditional sense, but by systematically refusing to command.

We built T2D3 OS, our AI-led go-to-market operating system, on the thesis that Marquet's model isn't just a good way to run a submarine or a company. It's the correct architecture for the relationship between founders and the AI systems that increasingly do their marketing work. This article is about why — and about the specific, sometimes painful lessons we learned encoding a naval leadership philosophy into software.

The problem with "leader-follower" — for sailors and for software

Marquet's central diagnosis is that most organizations run on what he calls the leader-follower model. One person at the top thinks; everyone else executes. Information flows up, orders flow down. The model has ancient roots and one great virtue: it's simple. It also has a fatal flaw that Marquet experienced firsthand when he gave an order that was physically impossible in his submarine's propulsion configuration — and the helmsman, knowing it was impossible, tried to execute it anyway. When Marquet asked him why, the sailor answered: "Because you told me to."

That sentence should chill anyone building or buying AI tools today, because it describes most of them perfectly. The dominant mode of AI in marketing is leader-follower with the human as leader and the model as an infinitely compliant crew: it will write the wrong blog post, target the wrong persona, and generate the wrong campaign, brilliantly, because you told it to. All the judgment stays with the human. All the labor moves to the machine. And the human becomes the bottleneck for every single decision, exactly as Marquet was the bottleneck for every decision on Santa Fe.

His alternative — leader-leader — rests on a principle that sounds simple and changes everything: move the authority to where the information is. The people who know the state of the reactor should make reactor decisions. The officer who knows the contact picture should decide the course. The captain's job stops being "make all decisions" and becomes "build the environment in which good decisions get made by the people closest to the facts" — through what Marquet calls the two pillars: technical competence and organizational clarity.

Now substitute "AI agent" for "sailor." The AI drafting your positioning knows your ICP research, your win-loss interviews, your competitors' messaging — it is closest to the information. Requiring it to wait for instructions before every step recreates the Santa Fe problem with better tooling. But handing it the keys with no competence checks and no clarity about intent recreates the opposite failure: authority without the two pillars is how you get confidently wrong AI. The interesting engineering problem — the one T2D3 OS is built around — is building both pillars into software.

"I intend to..." — the mechanism that changes everything

The most famous mechanism in the book is deceptively small. Marquet banned his officers from asking for permission ("Request permission to submerge the ship") and required them instead to state intentions: "Captain, I intend to submerge the ship." Followed by why, and what they'd checked. The captain's reply shrank to two words: "Very well."

Notice what this does. The thinking — is it safe, is the crew below decks, is the sonar picture clear — moves from the captain's head into the officer's statement. The captain still hears everything and can veto anything. But the default flips: action is the norm, and the leader's role is oversight, not initiation. Marquet describes this as pushing authority down until the crew are no longer waiting to be told; they are telling you what they're about to do.

This flip — from ask-then-act to announce-then-act — is, we'd argue, the single most important design decision in any agentic AI system, and it's the one most AI products get wrong in both directions. Chat assistants ask permission for everything and drown you in questions. Autonomous agents act silently and surprise you later. The Marquet pattern threads the needle: act on what you know, say what you're doing, make the veto cheap.

In T2D3 OS, this pattern is written directly into our engineering constitution as a principle we call "Agents lead; humans steer." Every module in the product — ICP definition, personas, value propositions, content, campaigns — is required to behave like a proactive officer, not a waiting sailor. The rule as we wrote it: the module drafts before being asked, and it does the ordering, merging, estimating, and prioritizing itself. When our review panel of specialist AI agents scores a new feature request highly, it doesn't file a report and wait — the item promotes itself onto the roadmap as a candidate, marked clearly as the machine's initiative, for a human to keep or kill. When a company locks its brand foundation, the system starts rendering brand-true visuals for every unillustrated draft in the library, in the background, without anyone clicking "generate." That is "I intend to submerge the ship," implemented in TypeScript.

But — and this is the part that separates Marquet's model from mere automation — the announcement matters as much as the action. A ship where the crew acts without informing the captain isn't leader-leader; it's anarchy with good intentions. So every autonomous action in our system reports upward through what a sailor would recognize as the deck log: a daily digest that tells the founder what the ship did on its own — which failed jobs healed themselves, which items the agents promoted, what's queued. A quiet day with an active watch still produces one compact line. We adopted an explicit rule for this: acting without informing is as broken as waiting without acting.

Competence and clarity, in software

Marquet is emphatic that you cannot simply "empower" people and walk away. Divested control without competence is chaos; without clarity, it's misalignment. Santa Fe's turnaround worked because the mechanisms of empowerment were matched by relentless investment in technical excellence ("we learn, everywhere, all the time") and shared understanding of the mission.

Translating the two pillars into an AI system turned out to be the deepest part of the work.

Competence, for an AI marketing system, means grounding. An agent's authority to draft your messaging must be earned by what it actually knows about your business — not by the eloquence of a large language model. So we made grounding structural: our system maintains a foundation layer (ICP, personas, value propositions, brand) that every downstream generation is required to draw from, and we enforce — mechanically, in our build pipeline — that AI generations cite the signal they're grounded in. A generator that produces output without declaring its evidence fails our automated checks the same way untested code fails a build. We call the underlying principle glass box: you should always be able to ask "grounded in what?" and get a real answer.

Clarity means the machine knows what the mission is — and what it isn't. Our equivalent of Marquet's "organizational clarity" is a set of written product principles the agents operate under, including an autonomy ladder we lifted almost directly from the book. Every AI capability in the system is classified: proposal only (the agent may suggest), draft for review (the agent may produce work that a human approves), or auto (the agent may act, announce, and be vetoed). And the ladder is explicitly tied to earned trust: autonomy is proportional to how rich and locked the company's foundation is. A brand-new workspace with an empty ICP gets a cautious crew. A mature workspace with locked foundations and months of human feedback gets officers who run their own watch. That's Marquet's competence-clarity gate, expressed as an access-control policy.

And some decisions stay with the captain, on purpose. Marquet never pretended every decision belonged at the bottom. In our system, the irreducibly human acts are named in the constitution: votes, locks, final approvals, feedback, and genuinely novel insight. Destructive or outward-facing actions — deleting data, publishing to the world, emailing a customer — always propose and never silently act, regardless of trust level. The ship can steer itself; only the captain authorizes weapons release.

The failure that taught us the real lesson

Here's the confession that makes this article worth reading: we violated Marquet's core principle inside the very system we built to embody it, and we didn't notice until our founder did.

T2D3 OS includes an autonomous fixer — an AI engineer that picks up approved bug reports, writes the fix, runs the tests, and opens a pull request. At one point, a configuration bug in the fixer's own environment caused dozens of its runs to die before doing any real work. The system dutifully marked each item "Fixer failed." And then it waited. Forty-three items sat in a queue, each displaying a failure message that contained the exact evidence that the failure was environmental — and each offering the human exactly one button: try again.

Our founder's question, reviewing that screen, was the right one: why am I finding this out by asking? The failure notes knew what had gone wrong. The fix for the environment had already shipped. Every piece of information needed to requeue those items existed inside the system — and the authority to act sat with a human being who had to click forty-three times. Information in one place, authority in another: the precise disease Marquet diagnosed on Santa Fe, reproduced in a system with his book cited in its constitution.

The one-time repair took minutes. The Marquet-grade repair took a design change we now call watchstanding, after the naval practice that inspired it. On a well-run ship, sailors on watch don't wait for the captain to notice corrosion — they run their rounds, fix what they find, and log it. So we built a registry in which every failure state in the system must declare who acts on it by default: does it heal itself under a bounded rule, does a retry budget own it, does it escalate to a human with full context, or is it genuinely a judgment call — and if so, why? Our build pipeline now rejects any new code that writes a "failed" status without answering that question. The forty-three stranded items became the founding case: failures matching that environmental signature now requeue themselves, exactly once, and report it in the deck log.

The lesson generalizes far beyond our codebase. Every "stuck" state in your business is a place where information and authority have come apart. The report that sits unread, the approval that waits on a vacation, the alert nobody owns — each one is a helmsman executing an impossible order because someone told him to, or a sailor watching corrosion spread because reporting it isn't his job. Marquet's question — who has the information, and do they have the authority? — is a diagnostic you can run on any process, human or machine.

What this means if you're a B2B founder

You don't need our product to apply this. You need the model. Three translations from the submarine to your go-to-market:

First, stop delegating tasks to AI and start delegating outcomes with intent. The leader-follower way to use AI is a thousand prompts: write this email, now this one, now this one. The leader-leader way is to invest in the foundation — a real ICP, sharp personas, honest positioning — and then let systems (or team members) state intentions against it: "Based on the locked ICP, I intend to prioritize these three content themes; here's the evidence." Your job shifts from generating instructions to granting or withholding "very well." It is less work and more control, which is Marquet's paradox in a sentence: he gained command of his ship by giving up control of it.

Second, demand glass boxes. Marquet could push authority down because his crew's thinking was audible — intentions stated aloud, reasoning open to challenge. Any AI system that wants authority over your marketing owes you the same: what is this draft grounded in, which signal, whose feedback shaped it? If a tool can't show its reasoning trail, it's asking for leader-follower trust — because you told me to — and it will fail you the way compliance always fails.

Third, build a deck log before you build autonomy. The instinct when adopting AI agents is to focus on what they can do. Focus instead on how you'll hear about what they did. A daily digest of autonomous actions — what healed, what was proposed, what's waiting on you and why — is the difference between a crew you trust and a black box you fear. Autonomy without reporting isn't empowerment; it's abdication. Marquet would tell you the captain who doesn't know what his ship did overnight hasn't distributed control. He's lost it.

The B2B companies that grow fastest in the next decade won't be the ones with the most AI or the ones with the most human oversight. They'll be the ones that get the relationship right: competent, grounded systems that state intentions and act; humans who steer, veto, and supply the judgment only humans have; and a culture — encoded in software the way Santa Fe encoded it in habits — where nobody, human or machine, ever waits idle in front of a problem they already understand.

Marquet turned followers into leaders and took his ship from worst to first. The ships are different now. The principle holds.

---

T2D3 OS is the AI-led go-to-market operating system built on the T2D3 methodology — where agents lead the work of marketing and founders steer it. The principles in this article — agents lead, glass box, autonomy earned by foundation — are written into the product's engineering constitution, and yes, the watchstanding registry is real code.