A field guide · October 2026

The Operator’s Handbook

Running a one-person machine with AI agents, day by day
by Mat Siems
Part I

The Operator's Chair

What the job is when agents do the typing.

Chapter 1 · Part I

One Person, Many Hands

This is a handbook for a particular kind of worker: one person, no staff, and a fleet of AI agents that will cheerfully do almost anything you ask of them, at any hour, in parallel. You might be a freelancer, a founder with no co-founder, a consultant, a writer with a codebase, or simply someone who noticed that the number of things they can get done in a day has stopped being limited by how fast they type. You are, whether you like the word or not, an operator.

The word matters because it names the job honestly. You are not a manager, because nobody reports to you who can take responsibility for anything. You are not quite a maker any more, because most of the making is done by something else. You run a small machine. The machine is made of agents, tools, notes, a list of projects and, most importantly, your own working day. When the machine runs well, a single person ships the output of a small team. When it runs badly, a single person spends the whole day supervising chaos and goes to bed with nothing finished.

What separates the two is rarely the tools. Everyone has roughly the same agents now. The difference is the operating system: the habits that decide what gets started, how it is described, how it is checked, when it ships and what gets written down afterwards. Those habits are what this book is about. It is not a business book. It will not tell you what to sell or how to price it. It is about the inside of one person's working day, and how to make that day produce finished things rather than busy feelings.

The agents supply the hands. You supply the order in which they move.

The book runs in ten parts. It starts with the job itself, then walks through the operating day, the writing of briefs, memory and notes, the project register and the delegation of threads, the reviewing of work, release discipline, the weekly and quarterly loops, the upkeep of tools and the handling of mistakes. It ends where everything in it points: the operator's real job is deciding, not doing. Each chapter teaches one thing you can try this week. None of them needs new software. Most need a text file and a little nerve.

A word on tone. This is written for people who are already a bit tired of being told that everything has changed. Plenty has. Plenty has not. People still need to know what they are trying to achieve, still need to check whether they achieved it, and still need to stop working at some point and eat dinner. Agents make the first two more important, not less, and they make the third harder to remember.

So start here, with a small exercise. Write down, in one sentence each, the three things your agents did for you last week that you would not have done yourself. Then write down the one thing you did that no agent could have done. That second list is shorter. It is also your job.

The operator runs the order, not the hands Start what gets started Describe how it is briefed Check how it is reviewed Ship when it goes out Record what is written down The operator one person sets the order the operating system The hands agents tools notes projects Everyone has the same agents. The habits are the difference.
Fig 1 · One Person, Many Hands. Five habits ring the operator, who sets their order while agents and tools do the work.
Chapter 2 · Part I

The Day Is the Machine

Most people who run agents think of their system as a set of tools: this assistant, that terminal, these connectors, those scripts. The tools matter, but they are not the machine. The machine is your working day. It is the order in which things happen between waking and stopping, and it determines what the tools are pointed at. Two operators with identical tools and different days will produce wildly different weeks.

Think of the day as having three parts. In the morning you review: you read what happened while you were away, decide what matters now, and choose a small number of outcomes for the day. In the middle you run sessions: bounded stretches of time in which you brief agents, watch their work, review what comes back, and either ship it or send it round again. At the end you close: you record what finished, what did not and what tomorrow should start with, and then you stop. Review, sessions, close. Everything else in the operating day is a variation on that arc.

This sounds obvious, and it is, which is why so few people actually do it. The default day for an operator with agents is reactive. You open the laptop, notice that a background job finished, read it, fix something small, start a new thread because an idea occurred to you, answer a message, check another thread, and look up to find it is four in the afternoon and you have touched eleven things and finished none. Agents make this worse, because each one generates more output to look at. The machine without a shape becomes a machine for generating notifications.

A day without a shape is shaped by whatever shouts loudest.

The fix is to treat the shape of the day as a design decision rather than an accident. Decide when the review happens and how long it takes. Decide how many sessions the day can hold and roughly what size they are. Decide when the close happens and what it produces. Write these down somewhere you will see them. They will be wrong at first, and you will adjust them, but a wrong plan you can adjust beats no plan at all, because without one there is nothing to adjust.

It helps to notice that agents do not get tired and you do. The machine can run all night; the operator cannot. So the day is the part of the system that has hard limits, and hard limits are where design pays off. A database designer worries about the slowest query. An operator should worry about the scarcest hour, which is usually the first good one of the morning, and should spend it on deciding rather than on fiddling.

Try it this week. For five working days, write three times on a card: when review ended, when the last session ended, and when you closed. Do not try to improve anything. Just look. Most people discover that the close never happens at all, and that the review quietly merges into the first session. That is not a moral failing. It is a machine with a missing part. Fit the part.

Same tools, two different days Designed has a shape Review decide Session one outcome Session one outcome Session one outcome Close then stop Reactive no shape no close 11 things touched · 0 finished · notifications set the order 08:00 12:00 16:00 18:00 A day without a shape is shaped by whatever shouts loudest. Five-day card review ended · last session ended · closed
Fig 2 · The Day Is the Machine. A designed day of review, sessions and close beside a reactive day that finishes nothing.
Chapter 3 · Part I

Doing Versus Deciding

For most of working history, doing and deciding came bundled. If you wanted a report written, you decided what it should say and then you wrote it, and the writing took so long that it felt like the real work. The deciding hid inside the doing. You chose the structure while drafting the first paragraph, changed your mind about the conclusion halfway through, and the finished report was the record of all those small decisions.

Agents unbundle the two. The doing, which used to take hours, now takes minutes and can happen without you. The deciding does not shrink at all. If anything it grows, because the agent will do exactly what you decided, and if you decided vaguely you get a vague result very quickly. The operator's day therefore tilts. Less of it is spent making things. More of it is spent choosing what to make, describing it precisely, judging what came back, and choosing again.

This is uncomfortable for anyone whose identity was built on doing. Making things is satisfying in a way that deciding rarely is. You can point to a page you wrote or a feature you built. It is harder to point to a good decision, because good decisions mostly look like nothing happening: a project not started, a feature not added, a bad pull request not merged. The temptation, when agents take away the doing, is to grab some of it back for the comfort, to rewrite the agent's draft in your own words when the draft was fine, or to fix the bug yourself because waiting felt idle.

Resist the temptation, but not dogmatically. There is a simple test for any piece of work in front of you: does this need to be done by me specifically? Some things do. A conversation with someone who trusts you. A judgement about quality only you can make. A piece of writing whose whole value is that it is yours. Everything else is a candidate for delegation, and the question becomes how to brief it well rather than whether to do it yourself.

Doing feels like progress. Deciding is progress.

Notice also that deciding is not the same as thinking about things. Operators can lose whole mornings to deliberation that never lands. A decision is a sentence with a verb in it: we will ship the small version on Thursday; we will drop the second feature; we will rewrite the brief and run it again. If your thinking does not end in a sentence like that, it was not deciding. It was weather.

So this week, keep a tally. Each time you sit down to do a piece of work yourself, ask the test question first, and mark which way it went. Do not change your behaviour; just count. By Friday you will know what fraction of your day is doing that only you can do, and what fraction is doing you have not yet learned to hand over. The second number is the size of your opportunity. It is usually larger than you hoped, and also larger than you feared.

The test question A piece of work in front of you Needs me, specifically? yes no Only you a conversation built on trust a judgement only you make writing whose value is yours Hand it to an agent the question becomes how to brief it well, not whether to do it yourself Decide a sentence with a verb we will ship the small version on Thursday Doing feels like progress. Deciding is progress.
Fig 3 · Doing Versus Deciding. One test question routes each piece of work to you or to an agent, ending in a decision.
Chapter 4 · Part I

The Three Operator Questions

Every piece of work an operator starts should survive three questions. What do we want? Why now? How will I know? They take about a minute to answer, and the minute is the best-spent minute of the day, because work that fails them tends to consume hours before anyone notices it was never worth doing.

The first question, what do we want, sounds trivial and is not. Most failed agent runs fail here. The operator had a feeling, typed it into a prompt, and received something that matched the words but not the feeling. The fix is to answer in terms of a result rather than an activity. Not look at the onboarding flow but a new user can sign up and reach their first saved item without help. Activities can be performed indefinitely. Results either exist or they do not.

The second question, why now, is the operator's defence against the infinite. Agents make it cheap to start things, which means that the backlog of plausible ideas grows faster than any person can review the output. Why now forces you to rank. Perhaps something is broken and costing you every day. Perhaps a door will close next week. Perhaps it is simply the most useful thing on the list. All of those are fine answers. Because I thought of it this morning is not, although it is the most common one.

The third question, how will I know, is the one that makes delegation possible. If you cannot say how you would recognise success, you cannot ask an agent to achieve it, and you certainly cannot review whether it did. A good answer names a check: the tests pass and the new one fails without the change; the page loads on a phone; the summary fits on one screen and mentions all four suppliers. A bad answer is I'll know it when I see it, which means you will see something and then argue with yourself about it.

If you cannot say how you would know, you are not ready to ask.

The questions narrow as they go, which is why they are worth asking in order. The first one is broad and generous; it lets in anything you might want. The second filters by timing and cost. The third filters down to the work you can actually verify. What emerges at the bottom is small, specific and checkable, which is exactly the shape that agents handle best and operators review fastest.

You do not need a form for this. A line at the top of each brief will do. Some operators write the three answers as the first three sentences of every task, before any instruction. It looks a little ceremonial at first. After a fortnight you stop noticing it, and you start noticing instead how much less work you throw away. The questions do not make you cleverer. They simply stop you from being busy on the wrong thing, which, in a day full of eager agents, is most of the battle.

Three questions, asked in order What do we want? a result, not an activity Why now? rank it against the list How will I know? name the check Ready to brief small · specific · checkable FAILS WHEN THE ANSWER IS an activity I thought of it today I will know it when I see it look at onboarding novelty, not need an argument later If you cannot say how you would know, you are not ready to ask.
Fig 4 · The Three Operator Questions. Three questions narrow work down to something small, specific and checkable.
Chapter 5 · Part I

Throughput Is Not the Point

The first thing agents give you is volume. Ask for ten variations and you get ten. Ask for a feature and you get the feature, its tests, a migration and a tidy summary. Start five threads before lunch and you will have five sets of results by teatime. It is intoxicating, and like most intoxicating things it is a poor guide to whether you are getting anywhere.

Output is what the machine produces. Outcome is what changes in the world because of it. An operator can generate enormous output with no outcome at all: drafts that are never published, branches that are never merged, prototypes that are never shown to anyone. The dashboard looks busy and the work looks impressive and nothing has moved. This is the busy trap, and agents dig it deeper, because the cost of producing one more thing has fallen almost to zero while the cost of finishing one more thing has not fallen at all.

Finishing is expensive because it involves you. Someone has to review the work, decide it is good enough, push it into the world, and deal with what happens next. Each of those steps draws on your attention, which is fixed. So an operator who starts more than they can finish is not increasing their throughput. They are building a queue, and queues have a habit of turning into guilt.

Started is a cost. Finished is a result.

It helps to picture your work on two axes. One axis is output: how much was produced. The other is outcome: how much of it reached someone and made a difference. Most operators, when they first get agents, slide along the output axis and stay low on the outcome one. The quadrant you want is the one where output is modest and outcome is high: fewer things, finished. It feels less productive. It is enormously more productive, as anyone who has ever shipped one thing instead of starting four can tell you.

The practical habit is to measure finishes rather than starts. At the end of each day, count only what crossed the line: merged, published, sent, delivered, decided. Do not count threads opened or drafts created. If the count is zero, that is information, not a scolding. Look at why. Usually the answer is that too many things were started and none was given the review attention it needed to finish.

There is a secondary benefit. When you count finishes, you begin to brief differently. You stop asking agents for exploratory sprawl and start asking for the smallest thing that could be finished today. You split large jobs into pieces that can each ship on their own. You notice that a half-finished large thing is worth less than a finished small thing, because the small thing can be used and the large thing can only be admired.

Try it for one week: a single number on a card, finishes per day. Ignore everything else the machine tells you about how busy it has been. The machine is always busy. That is its nature. Your nature is to decide which part of that busyness becomes real.

Output is not outcome Outcome reached someone low Output: how much was produced low Few, finished the quadrant you want merged, published, sent feels less productive is far more productive Many, finished expensive every finish needs your review your attention is fixed rare for one person Quiet a rest day, or a stall nothing started nothing moved The busy trap where agents push you drafts never published branches never merged prototypes never shown count finishes per day, not threads opened
Fig 5 · Throughput Is Not the Point. Output against outcome: aim for few things finished, not the busy trap of many started.
Chapter 6 · Part I

Direct, No Preamble

Agents do not need to be warmed up. They do not need to be told that you hope they are well, that this is a bit of a strange request, or that you have been thinking about something for a while. They need to know what you want, what they should know to do it, and how you will judge the result. Everything else is preamble, and preamble costs more than it looks.

It costs, first, in clarity. A brief that opens with three sentences of context-setting makes the actual instruction harder to find, for the agent and for you when you reread it later. Agents give weight to everything in front of them, so a meandering opening can tilt the work in directions you did not intend. If you mention in passing that you are worried about performance, do not be surprised when a simple text change arrives wrapped in a caching layer.

It costs, second, in your own thinking. Preamble is often what we write while we are still working out what we want. That is a fine thing to do, but do it in a notebook, not in the brief. Draft freely, then delete everything above the first sentence that contains a verb and a result. What remains is usually the brief you meant to write.

Say the thing. Then say how you will know it is done. Then stop.

The same applies in the other direction. Ask agents to be direct with you. A good result leads with the outcome and the evidence, not a narrative of the journey. Done: the importer now handles empty rows; the new test fails on the old code and passes on the new; full suite green is worth more than three paragraphs describing the investigation. You can always ask for the story. You should not have to dig for the verdict.

This is not about being curt. It is about respecting the scarcest thing in the system, which is your attention. Every unnecessary sentence an agent writes is a sentence you have to read before you can decide what to do next. Multiply that by twenty threads a day and preamble becomes a tax on your whole operation. Many operators put a standing instruction in their project memory to this effect: lead with the result, then the evidence, then any open questions, and keep the summary short. It is one of the highest-return lines you can write.

Directness also makes disagreement cheaper. If an agent thinks your approach is wrong, you want it to say so in the first line, not to bury the concern in the fourth paragraph after doing the work anyway. Ask for that explicitly. Plain speech in both directions turns the collaboration from a polite exchange of documents into something closer to a working conversation.

So, this week, look at your last ten briefs and cut the first sentence of each. Then see if the brief still makes sense. In most cases it will make more sense. The preamble was for you. The agent never needed it, and, if you are honest, neither did you.

Cut the warm-up, in both directions With preamble Direct Brief Report Hope you are well! This is a bit of a strange one I have been thinking for a while also worried about speed… Please fix the label text. Goal: fix the label text Done when: it reads Export Do not: touch the layout then stop First I looked at the… Then I explored how… Interestingly, the… After some time… …so it should work now. Done: empty rows handled Evidence: test fails, passes Full suite: green Open questions: none Say the thing. Then say how you will know it is done. Then stop.
Fig 6 · Direct, No Preamble. Preamble-heavy briefs and reports compared with direct ones that lead with the result.
Chapter 7 · Part I

Bias to Action, Bound by Evidence

Operators who do well with agents tend to share a temperament: they would rather try something than discuss it. When a question comes up that an experiment could answer, they run the experiment. When a draft is needed, they get one made and then argue with the draft rather than with an empty page. Agents reward this temperament handsomely, because experiments that used to take a day now take ten minutes, and there is no longer much excuse for long deliberation about things that could simply be tested.

But bias to action has a failure mode, and agents reward that too. The operator who acts fast without checking ends up with a lot of things that look done and are not. A migration that ran but quietly skipped records. A page that renders beautifully on a laptop and falls apart on a phone. A summary that is confident and wrong. Each one is cheap to produce and expensive to discover later, usually at the worst possible moment and often by someone else.

The answer is not to slow down. It is to bind your speed to evidence. Act as fast as you like, provided that each action produces something you can check, and that you actually check it before building on it. That is the overlap that matters: not caution, not haste, but quick moves that each leave behind a piece of proof. The operator lives in that overlap.

Move as fast as your evidence can keep up with.

In practice this means building the check into the action. When you brief an agent, include the verification step: run the tests, load the page, count the rows before and after, compare the summary to the source. When you take an action yourself, decide in advance what you will look at afterwards. If there is nothing to look at, either find something or acknowledge that you are guessing and treat the result as provisional.

It also means being honest about which actions are reversible. Trying a new layout on a branch is cheap to undo; act freely. Sending an email to everyone on a list is not; slow down and look twice. A useful habit is to label each action, silently, as either a sketch or a commitment. Sketches can be fast and sloppy. Commitments need evidence. Most of the trouble operators get into comes from treating a commitment as if it were a sketch because the agent made it feel so easy.

There is a pleasure in this way of working that is easy to miss. When every move leaves evidence, you stop carrying anxiety about whether things are really done. You know, because you looked. That frees attention for the next decision, which in turn makes you faster. Evidence is not a brake on bias to action. It is the thing that lets you keep your foot down.

This week, pick one task you would normally deliberate over and run it as an experiment instead. Before you start, write the one check that would tell you it worked. Then do it, check it, and see how long the whole thing took. It will be shorter than the deliberation would have been.

Move as fast as your evidence keeps up Act fast no checking skipped records breaks on a phone confident and wrong Check no acting long deliberation nothing tested slow to learn Operator quick moves with proof Sketch: reversible, act freely Commitment: needs evidence
Fig 7 · Bias to Action, Bound by Evidence. The operator works where fast action overlaps with checking the evidence.
Chapter 8 · Part I

Artifact First

There is a simple rule that saves operators a remarkable amount of time: when in doubt, make the thing. Do not describe the dashboard; get a rough dashboard built. Do not debate the structure of the report; have a draft written in two structures and read both. Do not imagine how the onboarding email will feel; produce it and read it as if you had received it. An artifact on the table ends more arguments than any amount of discussion about one.

This used to be expensive advice. Making a prototype took days, so it was sensible to talk things through first and build only once you were fairly sure. Agents have inverted the economics. A rough version of almost anything now costs less than the meeting you would have had about it, even if the meeting is only with yourself. So the order of operations changes. Instead of think, decide, build, it becomes build roughly, look, decide, build properly.

The reason this works is that people, including you, are much better at reacting than at imagining. Shown a page, you know within seconds that the headline is too long and the button is in the wrong place. Asked to imagine the page, you can spend an hour and still miss both. An artifact converts vague preferences into specific objections, and specific objections are things an agent can act on.

You cannot review an intention. You can review an artifact.

There are two disciplines that keep artifact-first from turning into artifact sprawl. The first is to label the artifact honestly. A sketch is a sketch. Tell the agent it is a sketch, so it does not spend effort on polish, and tell yourself it is a sketch, so you do not fall in love with it. Many operators keep a separate folder or branch for throwaway artifacts precisely so that nothing in it can be mistaken for real work.

The second discipline is to end each artifact with a decision. The point of making the thing was to learn something. Once you have looked at it, write down what you learned and what you will do: keep this direction, abandon it, or change one specific thing and look again. An artifact that does not lead to a decision is just output, and the previous chapters have been clear about what output alone is worth.

Artifact first also improves your briefs. When you have a rough version in front of you, the next brief can point at it: keep the layout, change the tone of the copy, make the table sortable. Pointing is far more precise than describing. The first artifact is often less valuable for itself than for the vocabulary it gives you to ask for the second.

This week, find a decision you have been putting off because you could not quite picture the options. Ask an agent for two rough versions, side by side, in whatever form the thing will finally take. Give yourself ten minutes to look at them. Notice how quickly the decision makes itself once there is something to look at. It usually just needed a face.

Build roughly, then decide BEFORE AGENTS: THINK FIRST Think Decide Build takes days prototype is costly NOW: MAKE THE THING FIRST Build roughly minutes Look react to it Decide one clear call Build properly point at it or change one thing and look again Label it a sketch throwaway folder or branch; no polish End it with a decision keep, abandon, or change one thing You cannot review an intention. You can review an artifact.
Fig 8 · Artifact First. The old order of think then build against building roughly, looking and deciding.
Chapter 9 · Part I

The Small Machine Rule

Every operator eventually builds too much machine. It starts innocently. You write a helpful script, then a template, then a set of instructions for a recurring task, then a dashboard to track the recurring tasks, then an agent to update the dashboard. Each piece makes sense on its own. Together they become a system that requires its own maintenance, its own documentation and, before long, its own operator. You set out to run a small business and discovered you were running a small software company whose only customer is you.

The small machine rule is a defence against this. It says: keep the whole system small enough that you can hold it in your head on a bad day. Not on a good day, when you are rested and curious and enjoy tinkering, but on a tired Thursday afternoon when something has broken and you need to know where to look. If you cannot sketch your system from memory on the back of an envelope, it is too big.

What does a small machine contain? Usually far less than people expect. One register of projects, so you know what is in flight. A handful of reusable recipes for the work you do repeatedly. A small, stable set of tools you know well. And, at the bottom of everything, one daily rhythm that tells you when to review, when to work and when to stop. That rhythm is the foundation; the rest sits on top of it. An operator with a good rhythm and three tools will outperform one with a bad rhythm and thirty.

If you need a manual to run your manual, stop building.

The rule cuts against a natural instinct. Agents make building tools so easy that it can feel irresponsible not to automate every repeated step. But automation has a carrying cost. Each script must be kept working as the world around it changes. Each template drifts out of date. Each connected service needs its permissions reviewed and its failures noticed. The cost is small for each and large in aggregate, and it is paid in exactly the currency you are shortest of, which is attention.

So before adding a new piece to the machine, ask two questions. Will I use this at least weekly? And will I notice when it breaks? If the answer to either is no, do the task by hand or by a one-off brief, and wait until the pattern proves itself. A recipe that you have run manually five times is ready to be written down. A recipe you have run once is a guess.

It is equally useful to subtract. Once a quarter, list every part of your system and ask which ones you have not used in a month. Remove them, or at least move them somewhere out of sight. Operators rarely regret a removal. They frequently regret the hour spent debugging a clever automation that was saving them four minutes a week.

This week, draw your machine. One page, from memory. Whatever you forget to include is a candidate for deletion. Whatever you cannot explain in a sentence is a candidate for simplification. The machine you can draw is the machine you can run.

A machine you can draw from memory One register what is in flight A few recipes for work you repeat A handful of tools small, stable, known well One daily rhythm review · work · stop: the foundation top base BEFORE ADDING A PIECE Used at least weekly? Would I notice it break? Add it both yes By hand either no run it by hand 5 times before writing it down Each quarter: remove anything unused for a month If you need a manual to run your manual, stop building.
Fig 9 · The Small Machine Rule. A small machine rests on one daily rhythm, with two tests before adding any piece.
Chapter 10 · Part I

The Name on the Door

There is one fact about the operator's job that does not change no matter how capable the agents become: your name is on the door. When something ships, it ships as yours. When it breaks, it breaks as yours. A client, a reader or a user will never ask which agent wrote the paragraph or which thread produced the bug. They will ask you, and they will be right to.

This is not a burden to resent. It is the thing that makes the job a job. If the agents could own the outcomes, they would not need an operator, and the whole arrangement would be simpler and considerably less interesting for you. Ownership is what turns a pile of capable tools into a working operation. Somebody has to decide what good enough means, and somebody has to answer for it afterwards.

What follows from ownership is mostly a matter of attention. Agents do the work, broadly and quickly. You review the work, narrowly and carefully, because reviewing is where your ownership becomes real. And you own the result, which means that the review must be good enough that you would be comfortable defending the result to someone who matters. That progression narrows as it goes: lots of work, less review, one owner. The narrowing is the point.

You can delegate the effort. You cannot delegate the apology.

Ownership also shapes the briefs you write. An operator who knows they will answer for the outcome writes clearer constraints, asks for stronger evidence and is less tempted to wave things through on a Friday afternoon. It is a useful thought experiment, before approving anything, to imagine explaining it to the person most affected by it. If the explanation would start with well, the agent decided, you have not finished reviewing.

None of this means doing everything yourself out of anxiety. That is the opposite failure, and it is just as common among conscientious people. Ownership is compatible with heavy delegation, provided that what you delegate comes back through a checkpoint you control. A good editor owns a magazine without writing every article. A good captain owns the ship without turning every bolt. The skill is in placing the checkpoints where they will catch what matters, which is what most of the rest of this book is about.

There is a quieter benefit, too. Owning the result gives the work a centre of gravity. When you are juggling a dozen threads and a fleet of agents, it is easy to feel that the work is happening to you rather than through you. Remembering that you will sign it pulls you back into the operator's chair. You stop watching the machine and start running it.

So this week, before you approve anything that will be seen by another person, pause for five seconds and ask: would I sign this? Not is it probably fine, but would I put my name on it. Most of the time the answer will be yes. The few times it is not will be the most valuable five seconds of your week.

Work narrows to one name Agents do the work broadly, quickly many threads You review it narrowly, carefully checkpoints you control You own it one name on the door Before approving: would I sign this? not "the agent decided" You can delegate the effort. You cannot delegate the apology.
Fig 10 · The Name on the Door. Work narrows from many agent threads to your review and finally to your signature.
Free preview · Part I

Keep reading

You have read the first 10 of 100 chapters of The Operator’s Handbook. The full book has every chapter and plate, as PDF and EPUB in English, French, Polish and Spanish.

The full book is coming soon to the shop.

Already bought it? Read the full edition online

The Operator’s Handbook · First Edition, October 2026
100 chapters · 10 parts · one hundred diagrams
by Mat Siems · MS Books, No. 15 · 2026