Twelve months ago, 1Health was a family conversation. A brother who is a rheumatologist, a gap in UAE healthcare discovery, a long night of sketching. Today it is live in BETA: patient profiles, provider listings, a back office, a brand system inside the product. The build that used to mean a funded team and a hiring plan is mostly me, plus agents I trust only as far as I can read their diffs.

That shift is the news, not the product. The question people ask is whether one developer can still run a real company. I stopped debating that and started watching what actually changed in the work. The typing moved to machines. Everything else stayed.

And the everything else turned out to be the company.

The first draft is cheap. The second one still costs.

Two years ago, AI coding meant autocomplete. Today you describe the outcome and an agent builds the first pass. Tools like Claude Code and Cursor-style agents hand you working software often enough that code volume stopped being the constraint.

But "first draft" is not only code. It is also a UX flow that compiles but misses the job. It is a feature from a roadmap slide that nobody asked for. Something plausible arrives fast; someone still has to decide if it is true.

Anthropic's CEO predicted last year that AI would write 90% of the code within months. He added a line that got less attention: "The programmer still needs to specify what are the conditions of what you're doing, what is the overall app you're trying to make, what's the overall design decision." The first part made headlines. The second part is the job description now.

What the org chart of one actually looks like

A one-person company does not mean the jobs disappeared. It means you hold all of them, and the agents only ever took one: the typing.

Somebody still decides what gets built. Somebody decides who can see a patient's information, because in healthcare that question has a body attached to it. Somebody decides what happens when a booking fails at night with a real person waiting. Somebody answers the support email. Somebody is legally on the hook.

An agent will decide all of that for you if you let it. It decides with a guess. The guess compiles, demos well, and is wrong in ways you find out from a user or a diff.

My actual day looks more like management than engineering. I read plans before any code gets written. I read diffs, never summaries, because the summary is the story the agent wants to tell and the diff is what happened. I hunt for the fallbacks and stubs agents leave when they were not sure their real approach would hold. That verification loop is a third of my week, every week.

I learned that rhythm at Paper, before coding agents existed. Generation was rarely what blocked us. The real test was whether a feature helped a teacher on an ordinary school day. Students landed on a plain white screen with a box prompting them to select a topic. They hesitated. We overlaid the topic selector on a preview of the chat underneath. Session starts went up by about 25%. Students called it obvious in hindsight. The second draft beat the first one because someone watched what actually happened.

Coding agents brought that same test to everyone who ships software. The first draft of the feature arrives in an hour. The second draft still comes from watching real sessions.

How you manage the volume

When agents produce migrations, components, tests, and glue in parallel, throughput stops being the bottleneck. Coordination and memory are.

Here is what that looks like in practice. I treat the board as the source of truth for what done means this week. Plans before code. I review the plan the way I used to review a sprint brief, then let an agent execute. Without that step, twenty parallel agents become twenty conflicting product visions.

Sessions are stateless. Scoped instructions are not. Written rules, skills, and checklists become the database of how you work: what to verify, what never to commit, which env vars matter. They survive session restarts so the next agent does not reopen decisions you already made.

MCP lets agents read the system instead of guessing. Deploy logs, DNS, email, database queries: the agent reads state, not chat memory. Process replaces colleagues as the error-correction system. A team is slower, but a team also catches blind spots. You rebuild that function out of boards, diffs, and end-of-session audits.

A test you can run this week

It comes down to one check. Open whatever the agent just handed you and ask two things before you ship it. What do I expect to happen? How will I know if it worked? If you can answer both, the agent gave you a real draft. If you cannot, the first pass was the easy part.

The bottleneck moved. It used to be how fast you could build. Now it is how fast you can decide and verify. Taste is knowing which agent guess matches the product you would ship. Critical thinking is asking why before you fix, because the miss shows you where the agent guesses and that knowledge compounds faster than any prompt trick.

At Openfair, an agent could hand us a demo in a day. Real users, real data, and real money still set a higher bar. The gap between the demo and that bar is where products earn trust.

I spent twenty years across design, product, and technical leadership before this. Every one of those jobs was judgment training. The agents made all of it suddenly relevant, because I now make in a week the range of decisions that used to be spread across a leadership team. Twelve months ago this was a family conversation. Write your own second draft.