I build PaellaDoc alone, with agents. Not as a slogan. As the actual daily shape of the work. Several sessions running at once, each on its own branch, while I move between them deciding what is worth keeping.
For most of the time I have built software, a solo founder had a hard ceiling. You could ship, but not at the throughput of a team. There were only so many hours and one pair of hands. That ceiling is mostly gone now. The agents write the code, and they write it fast. The building is no longer the thing that limits me.
Something else took its place, and it is harder to see because it does not look like a bottleneck. It looks like being busy. This is what a factory of one actually is, and where its real wall stands.
The roles a team splits, you now hold at once
A team divides labor so no single person carries the whole contract in their head. Someone owns product. Someone owns the code. Someone reviews. Someone remembers why a decision was made in March. The handoffs between them are annoying, but they are also how the work stays coherent while many hands touch it.
A solo founder with agents has all of that throughput and none of that division. I am the product manager who decided what we are building. I am the engineer who has to understand what came back. I am the reviewer who is the only person standing between a plausible-looking diff and the main branch. I am the memory of why this thing exists. The agents multiplied my output. They did not split my roles. Every one of those still lands on one person.
That is the trade nobody mentions when they say one person can now do the work of a team. You can produce like a team. You still decide like an individual, and deciding does not parallelize the way building does.
The bottleneck moved from your hands to your attention
Here is the shift, stated plainly. The scarce resource used to be how fast you could produce work. Now it is how fast you can absorb it.
Eight agents can generate more code in an afternoon than I can carefully read in a day. That is not a productivity win by itself. Unreviewed output is not progress, it is risk with a nice commit message. The moment the agents got fast, my attention became the constraint, and attention is the one thing I cannot buy more of or spin up another instance of.
This is what I mean when I say you are the runtime. I am the scheduler deciding which session runs next. I am the memory carrying context between them because they do not share one. I am the recovery loop when a run dies at 2am. I am the gate that says this is done and this is not. A team spreads those jobs across people and systems. Alone, they all run on me, and when I step away, they stop. The local software factory has one CPU and it is my head.
Where a factory of one actually breaks
It does not break on volume. It breaks on the things one person cannot hold.
Context loss. I finish a session, sleep, come back, and the thread is thinner than it was. Multiply that across parallel work and I am reconstructing what each branch was for before I can judge it. Drift. Two agents, working from the same idea in their own sessions, quietly diverge, and I only find it when their work has to meet. Review fatigue. When you are the only reviewer, the tenth diff of the day gets less scrutiny than the first, and that is precisely when something slips through.
None of these are throughput problems. Adding a faster model does not touch them. They are all the same underlying thing: the coordinating memory that a team keeps between its members, a solo founder has to keep alone, in one head, across more parallel work than one head was built to track. That is the wall. Not “can I build it.” Whether I can stay coherent while it gets built.
What the factory of one actually needs
If the constraint is my attention and my memory, then the leverage is not another agent. It is a system that holds the part of the work I cannot.
The durable layer has to live outside me. The product contract, so I am not the only copy of what we agreed to build. The decisions and their reasons, so March-me can answer for a choice August-me forgot. The code knowledge graph, so I can see the shape of what the agents built without reading every line. The evidence a task actually passed, so I do not re-review it out of distrust. When those live in the system instead of in my head, the parallel work stops depending on me being awake and remembering everything.
That is the difference between a solo founder who scales and one who becomes the single point of failure in their own company. Not more agents. A place for the coordinating memory to live that is not one tired person. The agents give you a team’s output. Something has to give you a team’s memory, or the output outruns your ability to keep it coherent and the whole thing quietly turns into a house of cards you built fast.
The limit I will not hide
A factory of one has a real wall, and I would be selling something if I pretended otherwise.
Judgment does not parallelize. The agents cannot decide what is worth building, whether the thing that came back is actually good, or when to throw away a week of work because the idea underneath it was wrong. Those stay with me, and there is a finite amount of that per day. Some of it is taste, some is context no model has, some is just the weight of being accountable for a call. Speed does not extend it. On the days I try to push past it, the quality of my decisions drops long before my ability to generate more code does.
So the real answer is that a solo founder can now operate like a team on everything except the thing that mattered most all along. You can build like ten people. You still have to decide like one. The whole game is arranging the work so that scarce judgment lands only where it is actually needed, and everything else runs without it.
Where PaellaDoc fits
This is the problem I am building PaellaDoc to solve, because it is mine. It keeps the factory’s memory outside my head: the product contract, the decisions, the code graph and the evidence live in one local system, connected, so parallel work does not depend on me holding it all together. The agents run isolated on their own branches. What they produce closes only when the evidence says it did, which is what lets me stop re-reviewing out of fear.
It does not make the judgment for me. I would not trust it if it claimed to. It does something narrower and more useful: it holds everything around the judgment, so the scarce thing I bring gets spent on the decisions that need me and nothing else.
If you are building software with agents alone, ask where your product’s memory actually lives. If the real answer is “in my head,” that is the wall you are going to hit, and it is closer than the throughput one.
Frequently asked questions
Can a solo founder ship serious software with AI agents?
Yes, and the old ceiling is mostly gone: agents write the code fast, so building is no longer what limits you. What replaces it is harder to see. One person now holds every role a team splits — product, engineering, review, memory, recovery, the quality gate — because agents multiply your output without dividing your roles. You can produce like a team, but you still decide like an individual.
What is the real limit for a solo developer using AI agents?
Attention, not throughput. Eight agents can generate more code in an afternoon than one person can carefully read in a day, and unreviewed output is risk with a nice commit message, not progress. The wall is coherence: context loss between sessions, drift between parallel branches, and review fatigue where the tenth diff gets less scrutiny than the first. Judgment does not parallelize, and there is a finite amount of it per day.
What is a factory of one?
A factory of one is a single person operating like a team by running several agent sessions at once, each on its own branch, while holding the schedule, decisions and quality gate alone. It works when the coordinating memory — the product contract, decisions, code graph and evidence — lives outside your head in one connected system. Otherwise you become the single point of failure in your own company, the CPU being one tired head.
Can AI agents replace a development team for a solo founder?
They replace the throughput, not the judgment. Agents cannot decide what is worth building, whether what came back is good, or when to throw away a week because the idea underneath was wrong. Those stay with you. What a solo founder actually needs is not more agents but a place for a team’s memory to live, so parallel work does not depend on you being awake and remembering everything.