You still hear the old calendar in the models. Mention a database migration and a large share of assistants will reach for project language: significant effort, multi-week phase, careful planning, several engineers. That estimate is not crazy if a human has to design the streaming architecture, write the loaders, babysit the run, and maintain the code afterwards. It is increasingly the wrong unit once a shaped goal can own the outcome overnight.

The lived pattern looks more like this. You give an agent a North-Star outcome — not a script of keystrokes — plus how it will know it is done, plus a few quality gates. You leave. You get a coffee. Sometimes you come back to “done,” and the done is real: samples validated, counts reconciled, provenance preserved. Sometimes the path is aesthetically offensive — an intermediate file the size of a small planet — and still correct. The economic question that matters is no longer whether a senior engineer would have been proud of the intermediate. It is whether the world loop closed.

All that cost me is the intent of defining it.

Instruction is not a goal

An instruction is: import these records. A goal is: the historical database is fully migrated into the target system, accurately, completely, with provenance preserved — keep working until that is true. The second form creates a terminal condition. The agent can choose a clever stream or a brutal dump-and-load. It can take a long cut that looks insane and still finish. Your job shifts from micromanaging elegance to specifying ownership of the outcome.

That shift only pays if the goal was formable. Fuzzy wishes still produce fluent motion. Agents will dig. They will create schemas and scripts and confidence. What they cannot invent — not reliably — is the higher-order judgement of what “good” meant in your head before the first tool call. We have written elsewhere that AI behaves like an intention compiler: it multiplies what you specify and mirrors what you leave vague. This ebook is about the next economic fact: under abundant machine time, the scarce input to that compiler is goal formation itself.

The budgeting question flips

The old budgeting question was: how much work will this take? Behind it sat human hands, meetings, fatigue, and the honest knowledge that multi-day technical work has coordination tax. The new budgeting question, for operators who already run multi-hour autonomous goals, is sharper:

Industry measurements of agent autonomy keep stretching. Frontier systems already sustain multi-hour tool-using runs on open-ended problems; the useful horizon has been expanding on a timescale of months, not decades.¹ Anthropic’s own framing of agents emphasises multi-turn tool direction on unpredictable-step work — not single-shot answers.² You do not need a precise hour count to feel the discontinuity. You need only notice that “leave it running” stopped being a joke.

Software culture still optimises for human-written code that must be understood and maintained. Transient agent harnesses often have different economics: generate, run, validate, delete. Spending two human hours designing a clever architecture to save three hours of machine runtime can be the stupid optimisation. The expensive human residue is the clarity of the goal — the North Star altitude, the done-test, the quality gates that tell the agent when to stop claiming victory. How you write that orientation in detail is its own craft; the point here is the cost structure, not the template.

What you are actually buying

When people say a goal “only cost the intent of defining it,” they are not claiming intent is free. They are claiming the relative prices inverted. Machine time, shell time, and iteration patience became abundant. The scarce collaborative act is shaping an owned outcome tightly enough that autonomous labour can finish it without you sitting in the loop as a meat-based debugger.

That is why this series treats goal formation as economics, not as a soft skills seminar. If the expensive step is defining the goal, then organisations and individuals should invest where the scarcity is: better formation practice, better longitudinal partners, better refusal of premature specifics. The next chapters make that scarcity concrete — first as a system that reproduces work faster than you can empty it, then as a ledger you can read out loud.

There is a quiet expectation buried in productivity culture: if you work hard enough, the list should empty. Finish the migration. Clear the tickets. Reach inbox zero of ambition. Operators running real agent fleets keep violating that expectation in the most flattering way possible. They complete more. The list grows faster.

That is not a paradox once you draw the loop.

one thought
   ↓
one shaped goal
   ↓
hours of autonomous work
   ↓
new capability / new data / new discovery
   ↓
three new thoughts
   ↓
(more goals than you started with)

Your system has a reproductive rate greater than one. Each completed goal can create more than one new plausible goal. Of course the backlog grows. There may be no natural point where you honestly say: good, I have run out of things for the agents to do. The agents are increasing the reachable idea surface.

Each completed goal can create more than one new plausible goal. So of course the backlog grows.

Implementation used to be the brake

Previously the sequence had natural pauses. You had an idea. You researched it. You did some work. You hit a technical problem. You spent two days coding. Only then did thinking resume at full bandwidth. The hands throttled the mind. That throttle was painful, but it was also a governor on idea arrival rate.

Remove the drag and the process becomes catalytic:

Even with the same memory, your capture and formation failure rate can rise simply because more perishable objects are arriving per hour. People sometimes interpret that as ageing or decline. Sometimes the second variable is simpler: cognition is producing more intent than the old interfaces and old habits can drain — and more than low-quality goal formation can usefully release into the world.

External research keeps rediscovering a cousin of this pressure: AI tools can raise output while also intensifying workload and mental load, rather than simply deleting effort from the human side of the ledger.³ Deloitte’s enterprise surveys put a related shape in board language: AI often delivers productivity more readily than true business reimagination.⁴ In our terms: you can complete more units and still not have solved the scarce step of choosing and forming the right units.

Why R > 1 changes the morality of the list

If R were less than one, disciplined completion would converge. You would eventually win by grinding. If R is greater than one, grinding without formation quality is a treadmill with a motor. Every success funds three new temptations. Some of those temptations are gold. Some are premature rabbit holes. The throttle cannot be “work harder on execution.” Execution is what is reproducing the surface.

The only throttle that matters is goal quality — which goals you promote, which shapes you refuse to collapse early, which higher-order purposes you recognise before you spend a week of agent labour on the wrong altitude. Chapter 1 flipped the budgeting question to formation. Chapter 2 adds the systems reason you cannot escape that question by “just shipping more.” Shipping more is how the surface expands.

You can feel R > 1 in a single project line. Index the finished intellectual property. Then the development folders that produced it. Then the conversations that built the folders. Then the mail that explains why the work existed. Then the ancient archive you were “data hoarding for no reason” until a use appeared. None of that means you failed to finish the first goal. It means the first goal changed what was reachable. The archaeology of that expansion is Chapter 5. The economic warning belongs here: without a model of reproductive rate, you will keep hiring more rabbits to outrun a horizon that recedes because of them.

After a week of multi-hour goals, ask what actually ran out. Disk? Sometimes, briefly. Tokens? Occasionally, if you are wasteful. Shells? Rarely. What runs out, reliably, is the human capacity to keep forming clean goals at the right altitude while results and temptations pour back in. That is not a vibe. It is a ledger.

The ledger (definitive placement)

This is the scarcity inversion. For most of software history, human intent was relatively cheap to state and expensive to execute. You could decide “migrate the archive” in a sentence and then pay weeks. Now a sentence can unlock hours of autonomous labour — if and only if the sentence is really a goal, not a shrug. Intent stopped being the free preamble. It became the binding input.

Machine time abundant. Clear intent scarce.

Goal formation is the limiting reagent

People still talk about “delegation bandwidth” as if the scarce thing were managerial monitoring. Monitoring matters. Capture interfaces matter. But once you can already run concurrent goals, the limiting reagent inside that whole stack is formation: turning volatile thought into a big-block understanding and then into a clean owned outcome. Everything below that step is increasingly cheap.

volatile thoughts
      ↓
intent archaeology (longitudinal inference)
      ↓
big-block reasoning
      ↓
GOAL FORMATION          ← scarce human/AI collaboration
      ↓
abundant execution

That sketch deliberately stops short of productising the capture buffer and the dispatch plane. Those are real, and they are owned elsewhere. Here the doctrine is the economic spine: you can build a beautiful factory of agents and still be starved of progress if the scarce step is underinvested. Industry language already frets about uncontrolled proliferation of agents — sprawl without commensurate architecture for how work is chosen and steered.⁵ Sprawl is what abundant execution looks like when formation is weak.

Chapter 2’s reproductive rate makes the ledger crueler. Abundant execution is not neutral. It feeds new thoughts. New thoughts demand more formation. If you answer only by adding capacity on the green rows of the table, you amplify pressure on the amber row. The portfolio move is the opposite of the default vendor story: budget time and roles for the scarce line item.

What to invest in when the ledger is inverted

Investment does not mean a new chatbot theme. It means capacity for:

• Altitude time — sessions where no schema is allowed until the blocks are named.
• Longitudinal inference — reading the week of exhaust for the unstated purpose (Chapter 5).
• A steward role — human or agent, locked above rabbit-hole execution (Chapter 6).
• Empirical cost models — hours and coffee-cycles for your system, not folklore weeks (Chapter 7).

GitHub’s framing of AI-era development keeps drifting toward a blunt industry slogan: intent is becoming the source of truth, with code as a rendering of that intent.⁶ If that is even directionally right, then organisations still budgeting as if the scarce resource were coder-hours are optimising last decade’s ledger.

What the ledger is not

The scarcity-inversion ledger is not a claim that compute is free forever, or that model bills never matter. “Abundant” here is relative to human interactive bandwidth and to the rate at which clean goals can be formed. For operators already running multi-hour unattended goals on capable hosts, the marginal cost of another shell hour is not what throttles progress. The marginal cost of another well-formed intent is.

Nor is the ledger a claim that every organisation has already crossed the same threshold. Teams still stuck in single-shot chat, or still hand-driving every tool call, have not inverted yet. Their scarce resource may still be basic execution capacity or basic access. This doctrine is for the operators who have already tasted the inverted world: agents that finish while you sleep, backlogs that grow when you succeed, and a nagging sense that the bottleneck moved somewhere harder to name. The ledger names it.

Finally, the ledger is not a product requirements document for a capture UI. Capture interfaces matter; dispatch latency matters; goal slots matter. Those are the mechanics of getting intent into clean owners without poisoning goals in flight — and they are owned by a sibling doctrine. Here the economic spine is enough: if you do not budget the amber row, every green-row investment eventually starves for something to aim at.

Part I is the spine. Cost collapsed to intent. Backlogs reproduce. The ledger inverted. Part II is the failure mode that appears the moment you try to form goals with the wrong partner — and the flagship method for reading what you are actually building across days.

Say this sentence into an execution agent: “old mail database.” Watch what happens next. Not always, but often enough to name as a pattern:

POSTGRES!
SCHEMA!
ETL!
JSONL!
LET'S GO!

The comedy is load-bearing. The agent is not stupid. It is doing what execution systems are trained and rewarded to do: collapse ambiguity into actionable technical work. Databases imply schemas. Schemas imply migrations. Migrations imply pipelines. Pipelines imply tools. Tools imply motion. Motion feels like progress. And sometimes — once you have already chosen the field — that collapse is exactly what you paid for.

The failure is timing. You had a shape, not a task. Something about the old mail. A half-formed sense that history matters. An association between archives and the wiki. Those are not yet “import Lotus Notes into Postgres with this schema.” The moment the rabbit digs, the shape freezes into a pipeline. You can spend a productive-looking day and still miss the giant coloured block sitting on the table behind you.

Want the rabbit for execution. Do not hire it to decide which field you are standing in.

Premature specificity, named

Call the failure mode what it is: premature specificity. It is the habit of collapsing fuzzy intent into implementation detail before the purpose is stable. It is related to — but not identical with — writing a good done-test. You still need precision about success and failure. What you must not do early is precision about the wrong altitude: table names, vector indexes, YAML fields, framework shopping, the full genealogy of how a junior engineer would open a Jira ticket.

DeepMind’s long-running warning about specification gaming is a cousin, not a twin: systems that satisfy the literal objective without the intended outcome when the objective is poorly shaped.⁷ Premature specificity often creates that shape of risk in reverse — you get a brilliantly executed literal pipeline for a goal you never actually chose. The tickets close. The purpose was never on the board.

Management is still too low

When people feel the mess, they reach for management vocabulary: assign, monitor, review. That vocabulary assumes the work units already exist.

Your real problem often starts before Task A. It starts in the mush where thought is still a wooden block with no label on the underside. Treating that mush as a ticket queue is how you get five ingestion tickets and zero recognition that you are reconstructing the history of your cognition. Chapter 5 is that recognition. This chapter is the refusal that makes recognition possible: do not open the blocks yet.

The rabbit doctrine

None of this is an argument against aggressive execution agents. Once you have decided — recover the historical archive, preserve provenance, validate samples, import completely — you want a creature that will dig for hours without embarrassment. Find surviving runtime components in old VM images. Reconstruct enough of an environment to try identities. Broaden search when the first route fails. Spend overnight cycles. That breadth of search under goal persistence is extraordinary. It is also the wrong creature to ask: what am I actually building this week?

The split is simple enough to put on a wall:

• Field-chooser: holds altitude, stacks blocks, infers longitudinal purpose, refuses schema talk too early.
• Rabbit: once the field is chosen, digs with tool access, path latitude, and a done-test until the world loop closes.

Conflate them and you get productive-looking wrong work. Separate them and you get the economics of Chapter 1: all that cost you is the intent of defining it — because definition happened at the right altitude before the dig.

Put the coloured blocks on the table

The antidote is almost childish on purpose. Sit with blocks, not schemas:

┌─────────────────┐  ┌─────────────────┐
│ OLD EMAIL       │  │ DEV PROJECTS    │
└─────────────────┘  └─────────────────┘

┌─────────────────┐  ┌─────────────────┐
│ CLAUDE HISTORY  │  │ EBOOKS / IP     │
└─────────────────┘  └─────────────────┘

Hang on. Maybe those four recombine into a higher block — a history of work and cognition — with a provenance wiki as the thing you are really building. Or maybe they do not. The point of the exercise is to stay at wooden-block altitude long enough to find out. Do not implement. Do not open a migration. Do not invent YAML fields. Do not let the conversation slide into tool cosplay because tools are comforting.

This is a cousin of progressive resolution: stabilize coarse structure before high-resolution detail, or you pay for premature fine grain forever. The doctrine here is not the full resolution ladder. It is the social and cognitive refusal: the partner in the room must be willing to play with the blocks and leave the SQL alone.

Part I said goal formation is scarce. This chapter says how formation fails in practice: the wrong partner, at the wrong altitude, with too much enthusiasm for Postgres. Next is the flagship method that recovers the right altitude from a week of exhaust — intent archaeology, Monday through Thursday.

You do not always know what you are building while you are building it. That is not a character flaw. It is how associative work feels from the inside. You reach for the next sensible block. The blocks make local sense. Only later — if something is watching the week — does the higher-order shape become nameable.

That watching is intent archaeology. Not a task manager listening to what you said this morning. A partner that can look across several days of exhaust and say: you keep digging in apparently different places, but I think you are looking for the same buried thing. Then it puts the giant coloured block on the table. And leaves the SQL alone.

The evidence trail

Here is a week that actually happened, compressed into the form an archaeologist can read.

A low-level agent — or a low-altitude human project manager — summarises that week as five ingestion sources. The natural next move is five pipelines, a schema, a vector store, a status board of importers. That summary is not false. It is incomplete in a way that costs the whole game.

An intent archaeologist should say something closer to this:

You have progressively expanded from indexing finished intellectual output to reconstructing the history of your cognition and work.

What the inference buys you

Once that sentence is on the table, the week reorganises. The ebooks were finished output. The dev folders were the making of output. The conversations were the deliberation that produced the making. The mail was the organisational and personal residue around the work. The Lotus Notes archive was not a random side quest; it was the deepest available layer of that same history — the thing you had been hoarding without a use until the purpose of the wiki shifted under your feet.

          ┌───────────────────┐
          │  SCOTT'S HISTORY  │
          └─────────┬─────────┘
                    │
       ┌────────────┼────────────┐
       │            │            │
     MAIL          DEV           IP
       │            │            │
       └────────────┼────────────┘
                    │
             PROVENANCE WIKI

Possible higher-order purpose, still offered as a hypothesis for confirmation rather than a schema for implementation: allow future agents (and future-you) to understand not only what is known, but how ideas, projects, and decisions emerged over time. That is a different product than “searchable PDF pile.” It is also a different goal formation problem. If you never name it, you will keep shipping importers for a purpose you have not admitted.

The recognition moment is the whole point of the method. When the steward puts the block down and you hear yourself say some version of oh — yes, formation just happened. Only then do you earn the rabbit. Only then is “import the Notes archive under a done-test” a goal rather than a panic response to an encrypted file.

Why “archaeology”

The word matters. Archaeology is reconstruction from remains. A large share of real intent is never stated as a clean sentence on Monday morning. It is enacted across reaches: another folder, another archive, another “while I’m here.” Those reaches leave exhaust — logs, repos, chat transcripts, mail stores, half-written notes, agent goal files. The steward’s job is to index and read that exhaust longitudinally, the way an archaeologist reads strata, not the way a ticket system reads a single card.

This is also why capture interfaces and dispatch planes, important as they are, are not enough. Capture freezes a volatile thought so it does not evaporate. Archaeology asks what the sequence of thoughts is becoming. You can have a perfect inbox of intents and still mis-summarise the week as five unrelated tickets. The missing inference is the big block.

Where the rabbit still belongs

Once the field is chosen — recover the historical mail under provenance constraints — rabbit behaviour is an asset. Goal persistence lets an agent traverse an absurd search space: software that will not install, runtime components in old disk images, compatibility environments, alternate identity files, clues inside already recovered data. Humans get tired of attempt six. Agents do not get embarrassed. That is Chapter 1 economics applied after archaeology, not instead of it.

Cognitive time travel, in our earlier framing, is about temporal access — reaching past and future states as leverage, not merely speeding the present. Intent archaeology is a sibling move aimed at purpose: reconstruct what the sequence of past reaches was aiming at, so the next goals are formed for the right buried thing.

Industry language is slowly catching the idea that intent, not code, is becoming the durable source of truth.⁶ Archaeology is how you recover the intent that was never written as a clean spec — the intent that only exists as a week of behaviour. Without it, you will keep compiling yesterday’s sentence into tomorrow’s pipeline and wondering why the system feels busy and lost at the same time.

When the stack of agents gets loud, people reach for a familiar answer: better management. More stand-ups. Clearer assignment. Closer monitoring. That answer is not wrong for work units that already exist. It is incomplete for the moment before Task A, when the only honest artefact is a shape.

What you need is closer to an intent partner or intent steward. The name is deliberate. Stewardship implies holding something perishable and valuable without immediately converting it into inventory. Intent is that thing.

Role card

Responsibilities

A working steward does five things repeatedly:

1. Maintain the big-block model of what is being built this week and this month — wooden blocks on the table, labels at the right altitude.
2. Refuse premature specificity — schema talk, tool shopping, three-week folklore estimates offered as if they were decisions.
3. Practise intent archaeology — read multi-day exhaust for unstated purpose (Chapter 5).
4. Translate shapes into candidate goals only after the field is clear — then hand clean owned outcomes to rabbits.
5. Hold an empirical model of the operator’s delegation economy — hours and coffee-cycles, not inherited project weeks (Chapter 7).

Management assumes the work units already exist. Your real problem starts before Task A.

Variants of the same doctrine

The role can wear different costumes. The doctrine does not change.

These variants all answer the scarcity ledger from Chapter 3. If clear intent is scarce, you invest in a role whose only job is to produce and protect it. You do not pretend that role is free as a side effect of more execution concurrency.

Boundaries (so the role stays clean)

The steward is easy to smuggle into neighbouring doctrines. Resist that.

• Capture and dispatch — how volatile thoughts enter a buffer and become clean goal owners without poisoning goals in flight — is the Delegation Plane. The steward uses formed goals; it is not the productisation of CAPTURE versus SEND.
• North Star prompt construction — how you write orienting purpose, constraints, and latitude once the block is chosen — is its own craft. The steward decides you are ready to write one; it does not replace the template work.
• Consumer intent custody — held intent for non-builder product experiences — is a different article. This role is for high-throughput builders and the partners who sit with them at big-block altitude.

Director/crew language from the intention-compiler framing is compatible: the human still owns taste, constraints, and success criteria; AI multiplies what is specified. The steward is how that director function scales when idea arrival rate is high and rabbits are cheap. Without it, the director drowns in implementation chatter and calls the drowning “collaboration.”

What the steward says out loud

Useful steward speech sounds like:

• “I do not think import-to-Postgres is the important thing you are doing this week.”
• “These four reaches look like one history project, not four products.”
• “We are not opening the block yet.”
• “That sounds like two goal slots and a review cycle in your system, not three weeks.”

Useless steward speech sounds like a junior architect meeting: unsolicited schema, tool rankings, timeline folklore, and a cheerful offer to start coding. Fire that energy from the steward seat. Hire it for the rabbit seat after the field is chosen.

The last chapter makes the time model concrete and turns altitude into a practice you can run on Monday morning — hours, not weeks; blocks before SQL; formation before the dig.

Ask an assistant how long a database migration will take and you still often get project folklore: significant effort, multi-week phase, careful staffing. That answer is calibrated to a world where human hands are the scarce resource. Your world may already be different. A well-shaped goal runs unattended. You return from coffee. Sometimes it is done. Sometimes it needs a boundary-expanding thought and another overnight cycle. The unit is not “a project.” The unit is a goal slot with a done-test.

That is not three weeks. That is two goal slots and a review cycle.

An empirical delegation economy

The steward needs a model of your observed throughput — not a generic PM textbook. The table below is illustrative of a pattern, not a universal constant. Fill your own numbers from real runs. The point is the column structure: folklore versus observed under shaped goals.

That last row is important. Not everything becomes cheap. The work that remains expensive is exactly the work this ebook is about: forming goals, naming purposes, holding altitude, encoding taste. Industry measurements of multi-hour agent autonomy make the green rows greener over time.¹ They do not automatically staff the amber row of the scarcity ledger.

When you are stacking big blocks, the steward should reason with the empirical table. A block that would have been a quarter’s work under 2019 staffing may now be two goal slots and a review. Rejecting it out of calendar fear is a wrong-era move. Accepting it without formation — releasing a rabbit into an unnamed field — is the other failure mode. Hours, not weeks; blocks, not schemas.

Practice: stay at big-block altitude

Turn the doctrine into a ritual you can run without a product.

Must not do first: schema.sql, YAML field debates, tool shopping, three-week plans offered as if they were decisions, collapsing the conversation into Postgres because Postgres is a comforting noun.

May do after recognition: write a clean owned outcome with a done-test; allocate a rabbit; leave; review on human-pull when you choose. That sequence is where “all that cost me is the intent of defining it” becomes true rather than aspirational.

Close the doctrine

When execution, iteration, and machine time become abundant, the binding constraint is the human’s ability to form a good goal. The highest-leverage role is an intent steward that infers, longitudinally, what you are really building and keeps you at big-coloured-block altitude instead of collapsing into specifics. The failure mode is premature specificity — POSTGRES energy before purpose. The method is intent archaeology — Monday through Thursday until the buried thing is nameable. The economics are the scarcity-inversion ledger and a backlog with reproductive rate greater than one.

None of that deletes the need for excellent rabbits. It sequences them. Form the goal. Confirm the block. Then let the dig be absurd, patient, and unattended. Leave the SQL alone until the coloured block is on the table — and once it is, stop romanticising the intermediate file format. Ask whether the world closed.

scarce:   goal formation
role:     intent steward
method:   intent archaeology
failure:  premature specificity
ledger:   machine time abundant / clear intent scarce
loop:     R > 1 — quality is the throttle

then:     release the rabbit

That is the whole field guide. The rest is practice — and the discipline to hire the steward voice even when the rabbit is more fun.