khairold
← Back to Blog

/hq: running a company with AI roles, one hour a day

·
AIClaude CodeFounderWorkflowAgents

I’m building a small marketplace app on the side. I have a day job. I get about an hour a day for it, sometimes less.

The code is fine. AI agents build it from a phased plan with dot-plan, mostly unattended. On the day I wrote this, the build was 42 items done with 24 to go, ahead of schedule.

Everything else had nobody. Sellers to recruit. A business to register. A domain, store accounts, terms of use, a launch plan, a support process. All of it lived in my head and in a pile of research files. Each time I sat down, I spent the first part of my hour working out where things stood.

So I asked one question: what if the company got the same treatment as the code?

The test

Before building anything I wrote down what I actually wanted. In my own words:

I just need to be the founder and able to grasp everything quickly, to be right in the mix of things.

That’s the test for every part of the system. I don’t want a dashboard to manage, or a team of bots to supervise. I want to switch in from my day job, know where everything stands in two minutes, make the calls only I can make, and switch out.

The real cost isn’t the hour. It’s the context switch. Anything that doesn’t make catching up faster gets cut.

How it works

It’s a folder called company/ next to the code, plus one Claude Code skill, /hq.

The folder is plain markdown:

  • STATE.md: where everything stands. Short enough to read in two minutes. Rewritten at the end of every session.
  • INBOX.md: decisions only I can make. Each one comes with a recommendation. Most urgent at the top.
  • roles/: one short charter per role. Job, what it reads, what it writes, its limits.
  • BOARD.md: each role’s done / next / needs.
  • meetings/ and logs/: what happened, in date order.

A role is a viewpoint, not a separate agent. “Growth” is a page of markdown that tells a general agent what to care about and where to look. One exception: the critic always runs as a fresh subagent. It gets the material under review, never the reasoning that led to it, so it can’t be talked into agreeing.

Nothing runs unless I call it. No cron jobs, no agents working while I sleep. If something has to happen while I’m away (a buyer reports a problem at 2am), it goes into the product as automation, not into this system.

The company folder never copies the truth. Decisions already have a home (a decision table and a dated reasoning log). The build has its home (.plan/). company/ only points to them. And roles never touch app code: a product change becomes a new item in the build plan, and the build agents pick it up.

The commands

CommandWhat it does
/hqThe brief. One screen: what changed since last time, what needs me (max 3, each with a recommendation and rough minutes), one suggestion for today’s hour.
/hq meeting [topic]Every role with news reports done / next / needs, each as its own agent in parallel. A chair closes with decisions and action items.
/hq <role> [task]Do one job as one role.
/hq inboxGo through my decisions one at a time, recommendation first.
/hq weekNumbers, a short retro, next week’s three priorities.
/hq explore <idea>Strategy writes a memo, the critic tears it apart, both land in my inbox.
/hq adoptBuild or re-sync company/ from the project’s whole history.
/hq observeAn outside agent reviews the system itself. More on this below.
/hq closeEnd of session: log it, rewrite STATE, tidy the inbox.

Day one

I built the first version in about 20 minutes. Eleven roles, a hand-written STATE and INBOX. It felt complete.

It was wrong in ways I couldn’t see.

So I added /hq adopt. One fresh agent reads the entire project: every commit, the build plan, the research, the decisions, and my past sessions. It returns a map: what’s been decided, what’s been decided but never done, what’s been recommended but never decided, which promises have no owner, and where two sources disagree. Then it proposes which roles this project actually needs.

It cut my eleven roles to six plus the critic. Three got merged. Two got paused because there’s nothing for them to do yet: there are no metrics before there are users.

Then came the first meeting. Five role agents ran in parallel. Each read the full history of its own area and reported done, next, needs, and a list of gaps it found.

The headline from the chair:

The build is well ahead. The dates are now limited by founder steps, not code.

Every role’s top need traced back to the same few things only I could do: create the accounts, register the domain, register the business, pick the pilot area, talk to the first sellers. The code was waiting on me.

The roles found real gaps too. Some examples:

  • There was no way to go live. The build agents can deploy to staging but not to production, and nothing in the plan covered the step in between.
  • My seller target didn’t fit my hours. The plan assumed a pace of outreach that one hour a day can’t sustain. It got cut by a factor of ten, with a weekly ramp to match.
  • A seller who can’t log in had no way to reach us. Support was behind the login screen.
  • The press timing was off. The papers I wanted to pitch need the story weeks earlier than I’d planned.

It also caught errors in the STATE and INBOX I’d written by hand that morning: a wrong progress count, a wrong target, missing accounts. Writing it myself had been the less reliable option.

I made most of the decisions on the spot. Each went into the decision table and the reasoning log, and the product changes went into the build plan as new items. Then I spent the rest of the session doing the founder steps: domain registered, accounts created, first sellers messaged. The agent handled the browser work it could do, like the trademark searches. It also found a blocker no amount of planning would have caught: the business registration account has to be activated in person at a kiosk before you can use it online.

That was about 95 minutes, including building the system.

The mistake

The build was running in parallel the whole time, committing its own work. At one point /hq ran a plain git commit and swept the build agent’s staged files into a company commit.

Now /hq commits only its own paths, every time. It’s written into the skill and into my memory notes. Two systems sharing one repo need that rule.

Watching the watcher

A system like this can easily turn into the thing it was meant to replace: more files to read, more rituals, more of my hour.

So it has an outside observer. Every couple of weeks, /hq observe starts one fresh agent that isn’t part of the company. It reads my actual Claude Code sessions (every message I typed, how long each session took), the logs, the meetings, and the git history of the system itself. It looks for corrections, repeated asks, confusion, and things I did by hand that a role should have done.

It measures what matters for a one-hour founder:

  • Minutes from opening a session to the first useful action.
  • My minutes per week against the budget.
  • Decisions made per hour, and how old the oldest inbox item is.
  • Roles nobody calls and files nobody reads.

It proposes changes and never makes them. I approve each one. And its charter says: prefer cutting over adding.

To feed it, every /hq close writes two lines into the log: how many minutes I spent, and what was awkward. Day one’s awkward list: the git collision, my hand-written state being wrong, and an in-person step I couldn’t have known about.

What I learned on day one

Let the history design the org chart. I guessed eleven roles. The project’s own history said six. Roles should come from the work that exists, not from what a company is supposed to look like.

The bottleneck moves to you. Once agents build the product, the slow part is the human steps: accounts, signatures, conversations, decisions. A system that only tracks code progress misses this completely.

Every recommendation needs an opinion. An inbox of open questions is just more work. An inbox of “do this, here’s why, 10 minutes” is something I can clear between meetings.

Keep it small enough to throw away. It’s markdown and one skill. If a part doesn’t earn its place, I delete it.

What’s next

This isn’t refined, and it isn’t open source yet. It’s a day old. It grows the same way dot-plan did: by use, on a real project, with the observer pointing at what’s slow.

One idea is parked. A small band above the Claude Code prompt that shows days to launch, build progress, the inbox count and the top item, read straight from the files without spending a model call. I’ll build it if catching up is still slow after a few real sessions.

If it holds up through launch, I’ll package it the way I packaged dot-plan. Same principle as always: work on the system, not in the system. This time the system is the company.