AI Founder Mode
for the Rest of Us

Across the last year and a half, three of the most-watched founders in tech have publicly converged on the same direction. Each describes a different layer of it. Together, they describe one shift.

The thread underneath all three: dismantle the middle layer, put the intelligence at the center, let the founder stay close to the work. Three different jobs – one direction of travel.

But notice the cost of admission. Chesky had to fight his own org structure back to something more like an early Airbnb. Dorsey laid off thousands of people to clear the layer the hierarchy used to occupy. Graham's essay is read most hungrily by founders of companies that already over-hired.

All three are describing the long, painful walk back to where small but mighty teams already are.

We never built the middle layer. We don't have one to dismantle. The advice they're giving each other – stay in the details, intelligence at the center, founder close to the work – isn't a restructuring for us. It's our default state. AI Founder Mode is the first version of this idea that was actually built around what we've been doing all along.

Which is why it's worth getting concrete about what AI Founder Mode actually looks like on a Monday morning for two humans and a crew of agents.

The problem with delegation isn't the delegating – it's that the knowledge you build while doing the thing never leaves your head. The standards. The gotchas. The wait, that breaks if… So you hand off the task, the team member or agent runs at it, the result misses the unwritten standards, you redo it, and you quietly conclude that only you can do this right.

A small example from our week. A few weeks ago I sat down and recorded a series of explainer videos for the site – a Pirate Skills overview for the homepage, deeper walkthroughs for the sales pages, the lot. Two weeks later I genuinely could not tell you the state of those videos. How many had I recorded? Were they edited? Were the right ones on the right pages? Had any of them gone live?

A decision had been made – “we need new videos” – but the loop wasn't closed. The standards for how a Mux player should be embedded, what the loading behaviour should look like, which page each video belongs on – all of that lived in my head. And the moment my head wasn't in the loop, the loop opened up.

The fix is smaller than it looks. Next time the task comes up, do it once – with you guiding an agent through the work, and any team member who'll run it next time watching alongside. Could be uploading a new video to a sales page. Could be preparing this month's metrics dashboard. Doesn't matter. Every recurring process is a candidate.

Then, in the same session, run /skill-creator. It captures the standards, the gotchas, the wait, that breaks if… that lived in your head a minute ago, plus the exact steps the agent just performed. It's no longer yours alone.

Next time the job runs – a team member can run it, or an agent on a schedule – whoever runs it flags what felt off. In that same session, they explicitly ask the agent to apply the feedback and update the skill itself, so the friction doesn't happen on the next run. The skill gets sharper. So does the team.

The four-step founder loop, made boring on purpose:

No quarterly process audits. No SOP wikis no one reads. Just a closed feedback loop where every running of the skill makes the next running better.

The question that runs through my head now, whenever Christina asks me for something, is brutally short: do we already have a skill for that? If yes, great – she runs it, the agent does the work, we move on. If no, that's the cue. We do it together once. The agent writes the skill. She runs it next time without me.

The skill is the new onboarding. The codebase is the new Notion. The agent is the new hire that doesn't need three months and a salary to start contributing.

Which is the natural segue to where these skills actually live.

I noticed this slowly, then all at once. More and more of what used to be our company knowledge has migrated out of Notion and into our codebase. That sounds technical. It isn't.

Every time we add another abstraction layer above code – another no-code tool, another wrapper UI, another “non-technical-founder-friendly” surface – we re-create the same wall we've been trying to escape: the one between the people who are technical and the people who aren't. For small teams, that wall is the cap on what you can do. If you're unwilling to take the small jump into the codebase, AI Founder Mode probably isn't for you. And your competition won't be that polite.

The proof is in the loop we just walked through. Claude Chat, Claude Co-work, ChatGPT in the browser, Cursor in user-mode – they're great for the surface work. Until you try to close a feedback loop with them: give the agent feedback and ask it to update its own skill. In the user-level tools that's seventeen copy-paste steps spread across two conversations and a go open another window. In Claude Code, it's one sentence: apply this feedback and update the skill. Same model underneath. Different layer.

That's why our knowledge has been migrating to the codebase. Not because we became developers. Because the team members who actually run the work live there. Agents read code. They pull skills from files. They follow links between configs. The operational center of gravity has flipped, and the small teams that flip with it pull away from the ones that don't.

Underneath this is a simple principle: agents are team members. Team members need the right knowledge, the right context, the right tools, and the right access level to get the job done. The natural place for those four things to meet is the codebase.

On a small team there's no reason for the access map to look complicated. Christina and I have the same access. Our agents have access to whatever they need to close the loop on the task we gave them – and no more. The list is honestly not exotic: the codebase, the production database, Slack, my email, calendar, Stripe, the ad platforms, GitHub, Resend, Linear. The same tools any new hire would have been given in week one, except given on day zero.

The mental model that's helped me here is the “ask mode vs. auto mode” toggle in Claude Code. Every founder has a limited amount of patience for an agent that asks before every action. You quickly move to auto mode for the bulk of the work, and reserve the ask-before-acting boundary for the things that actually warrant it – deletions, money moving, anything where a prompt injection could turn into a real-world problem.

The same logic applies to the team. Maximum transparency between Christina and me. Maximum access for the agents on the things they need. Tight boundaries on the things they don't.

This is the bit AI Founder Mode adds to Founder Mode: not just stay in the details – turn each detail into a skill, put the skill in the codebase, and give the team (humans and agents alike) the access to run it.

Three moves. None of them require restructuring anything.

1. Write down the ten most repetitive tasks you or your team handle at least once a week. Don't overthink the list. The obvious stuff – status updates, content drops, weekly dashboards, invoicing, follow-up sequences – is exactly the right material. Pick the one where you can already picture an agent doing the bulk of it for you.

2. Open Claude Opus and do that one task with the agent. Don't write a brief. Just do it together, the way you'd walk a new teammate through it for the first time. Ideally prompt with your voice, not your fingers – speaking out loud is the fastest way to pull tacit knowledge out of your head and into the conversation. When the task is done and you're happy with the result, run /skill-creator in the same session and turn what just happened into a skill.

3. Hand the next run of that task to someone other than you. Two clean options. Schedule the skill against an agent – Claude Code routines, an OpenClaw teammate, whatever you've got – so the job runs itself on its own cadence. Or pass it to a human team member who can now do it exactly the way you wanted it done. Either way, when they hit a friction point, they give the agent feedback and ask it to update the skill in the same session. The skill gets sharper. The next run gets easier.

That's the whole AI Founder Mode loop. Graham, Chesky, and Dorsey are catching up to where small but mighty teams already started. Small isn't a phase you grow out of. Small is the strategy. AI Founder Mode is what makes it the strongest strategy on the board.

See you on the bridge.

Cheers,
Ben