A one-person company's real bottleneck isn't doing the work. It's remembering it.
Once AI agents do the work, your most expensive job becomes re-explaining where things stand to every tool. A product-agnostic handoff method, and a template you can copy today.
Monday morning, you spend an hour in ChatGPT settling the design for your payments module: which signature check, how retries work, what you're deliberately leaving out.
That afternoon you open Cursor. Your first move isn't writing code. It's pasting the morning's conclusions and typing "we decided earlier that..." Halfway through you realize you forgot to say "no refunds," and the agent has helpfully built refunds.
In the evening you want a second agent to test it, so you paste again. This time you paste the decision but not why you rejected the alternative, and the alternative comes right back.
That's what working alone with AI often looks like: the work gets done, but "where things stand" lives only in your head.
The bottleneck moved
Working alone used to be limited by hands. AI added hands. The limit moved: you became the human message bus between your tools.
Every time you switch, you re-explain the goal, what's decided, what's done, what's next, and what's waiting on you. Skip one line and you pay for it in rework.
On a team, a project manager, a weekly sync and a shared doc absorb this. A one-person company has none of those, so it all lands on you, and it grows with every tool you add.
The fix isn't a smarter agent
Before choosing tools, decide the minimum a piece of work needs in order to be remembered. I boil it down to five things:
- Goal: what "done" looks like, in a sentence or two.
- Decided: choices already made, and what you're not doing.
- Where it stands: what's finished and what's verified.
- Next step: the first thing whoever picks it up should do.
- Waiting on me: anything blocked on your decision, with the options laid out.
Three principles.
Record the task, not the conversation. A conversation is long, messy and tied to one tool. A task is the outcome: short, stable, readable by anyone who picks it up.
Whoever finishes writes it. You shouldn't maintain this. When an agent wraps up a round, it writes the handoff: what changed, how it was checked, what's left. You appear only in "Waiting on me."
Write down what you're not doing. Much rework isn't missed work. It's an agent doing something you'd already ruled out.
A template you can copy
No product required. One Markdown file is enough:
# Task: <one line on what this should become>
## Goal
<what it looks like when it's done>
## Decided
- Chose A, because...
- Not doing: ... (because ...)
## Where it stands
- Done: ...
- Verified: ... (how)
## Next step
- <first thing the next person should do>
## Waiting on me
- Question: ...
- Option 1: ...
- Option 2: ...
At the start of any new session, skip the recap and say: "Read this file, then continue." At the end of each round, have the agent update it, not you.
When one file stops being enough
One person, one agent, one repo? A TODO.md is plenty. Don't add anything.
The file starts to strain when you run several projects, hop between ChatGPT, Cursor and Claude Code, want to check progress and reply "go with option A" from your phone, or want to look back at why something was decided three months ago.
That's when you want one record that every tool can read and write, and that you can answer from your phone.
That's how I do it: the task lives in StateDock, ChatGPT writes it while planning, Codex or Cursor claims it to build, the agent submits a handoff when it's done, and anything needing my call is pushed to my phone. It records state; it doesn't plan or execute for me. But you can start with the template above and see what it feels like when switching tools stops meaning starting over.
Get the remembering out of your head first. The rest can wait.