Skip to main content

Mode 2 — Manufacturing

Build it once, and it works without you. You manufacture a durable worker (a Digital FTE) that does the job again and again, on its own.

You arrive here from From One-Off to Worker with two things in hand: a solution you have already proven by solving it in Mode 1, and a blueprint for the four promotions that turn it into a permanent worker. Mode 1 taught you to solve a problem once, by hand. Mode 2 is where you build the worker that solves it for you, forever.

This is the turn the whole book is built around: from labour as a task (you spend the hours every time) to labour as an asset (you build once, and it produces while you sleep). The worker you manufacture has a name in this book: a Digital FTE, a "digital full-time employee". It is a worker that runs unattended, reliably enough that an organisation can depend on it, that you can grow into a whole workforce, and that you can sell.

Two modes, one last time:

  • Mode 1 — solve it once. You drive. The work is one-off. (The previous section.)
  • Mode 2 — manufacture a worker (this section). You build to last. The work runs without you.

This section is larger and more technical than Mode 1, and honestly so: building something durable and trustworthy is more work than solving something once. But you do not need to be a programmer. As in the rest of the book, you direct and the agent writes most of the code. Your job is to understand the parts well enough to design and judge them. The section is built as a clear progression, not a pile of topics.

The section in three phases​

It mirrors the path you already walked in Mode 1 (diagnose, solve, cross) but one level up: gather the building blocks, assemble them into one trustworthy worker, then scale that worker into a workforce.

Diagram of the Mode 2 path as three phases, left to right. A note on the left shows you arrive from Mode 1 with a proven solution. Phase 1, "Building Blocks," is the pieces a worker is made of: Python, connectors, plugins, and identity. Phase 2, "Build Workers," is where you own the agent loop: agent, memory, Digital FTE, and reliability. Phase 3, "Scale the Workforce," is one worker becoming a team: design, govern, deploy, and earn. A forward arrow leads on to an AI-native company. A caption reads: Building Blocks, then Build Workers, then Scale the Workforce.

Phase 1 — Building Blocks​

Before you own a full agent loop, you gather the pieces a worker is made of: the language it is written in, the first small whole things it plugs into, and the identity that lets it act as you.

  • Python in the AI Era — the language workers are built in, taught the modern way: you direct, the agent writes most of it, and you learn to read and steer what it produces.
  • Connector-Native Apps — ship one whole thing before you own a loop: a remote server the host's model calls, with tools, state, identity, and a live run in claude.ai. The gentlest first build, and it earns the next course by letting you feel exactly where a loopless app hits its ceiling.
  • Plugins for AI Agents — the mirror of the course before it: there you extended the chat app; here you extend the coding agent. Bundle all four levers (skill, subagent, MCP server, hook), make a must-always rule deterministic with an exit-2 hook, and ship it so a teammate installs the whole thing in one command.
  • AI Identity — the identity and access layer: first own your own sign-in (email and social login, sessions, two-factor, an OAuth/OIDC server), then give an AI worker its own credential and a safe, scoped, revocable, human-approved way to act on your behalf. The through-line is one question you can ask of any system: whose identity is this, and how does authority pass from a human to an agent?

Phase 2 — Build Workers​

Now you own the loop. You take the building blocks and assemble one worker that runs the job itself, works from a memory larger than any prompt, and survives the real world while no one is watching. (The first promotion, your brief becoming a written spec, you already learned in Spec-Driven Development back in General Agents, and you bring that with you.)

  • Build AI Agents — the core worker: it runs the loop itself and stops to escalate at the edges. This is your you-in-the-loop promotion, made real.
  • AI Searchable Context — give the worker a searchable memory so it can work from your whole body of knowledge, not just what fits in a single prompt.
  • Building a Digital FTE — assembles the core pieces (portable Skills, a Postgres system of record, MCP as the wire between them, audit trails, and approval as the authority model) into one worker an organisation can actually trust.
  • AI Agent Nervous System — durable execution: the worker senses events, retries when something breaks, waits at no cost, and pauses for human approval. This is what lets it survive the real world while no one is watching.

Phase 3 — Scale the Workforce​

One trustworthy worker is the unit. A workforce is the business. This phase turns the one into many: designed for people to trust, graded so it stays reliable, deployed so it keeps running, governed, and earning.

  • Human-Agent Teams — the operating model for running people and Digital FTEs as one team: work in the open, one roster with clear roles, a north star, and trust that grows with verified reliability. You leave with a real team's operating manual you can run today.
  • Designing Agent Experiences — an agent product has two users at once: a human who must trust it and other agents who must parse it. You learn to make its judgment legible, its autonomy adjustable, and its mistakes survivable, then ship an MCP App.
  • Workforce with Paperclip — one worker becomes a team: a lead agent hires and runs a board of workers under budgets, approvals, and a full audit trail.
  • Self-Expanding Workforce — a workforce that grows itself as the work grows, instead of you adding every worker by hand.
  • Identic AI — owner delegation done safely: a signed identity that clears the routine approvals inside limits you set and surfaces only the consequential ones, so you govern a workforce without rubber-stamping every step.
  • Eval-Driven Development — the eval that grades the workforce automatically and catches it the moment it drifts. Your eyeball-check promotion, made real.
  • Deploy the Agent Harness — the runtime the workers live on, so they keep running when you are away. Your session-becomes-runtime promotion, made real.
  • Choosing Agentic Architectures — the reference you reach for when a design decision comes up (one agent or several, which pattern fits the job): five questions about the task map to one of four core patterns, so you choose by fit, not by what looks impressive.
  • Payment-Enabled Agents — workers that can transact, so a worker can also earn. This is the step from a workforce that saves you cost to one that brings in revenue.

What you need first​

Come in through From One-Off to Worker. Mode 2 is far easier when you arrive with a solution you have already proven and a blueprint to build from, rather than a cold idea. You should also have done Spec-Driven Development (the spec is your first promotion). Python is taught here, in Phase 1, so you do not need it beforehand.

Where it leads​

A Digital FTE is one worker. A workforce is many. Beyond this section, the book follows that line to its end: an AI-native company built on a workforce of Digital FTEs, and the business of selling the workers you can now build. You came in able to solve a problem once. You leave able to manufacture the thing that solves it forever, and to sell it.

Start with Python in the AI Era.