A Wednesday in November · one real day, told as it happens
No theory. One working day of a two-brains company: one person, one Claude with a kit, a few other agents, a client with real users. Each entry says what happened, which part of the kit did it, and what a plain chat with Claude would have done instead.
Anastasia writes late: she wants every agent to be able to leave a hurtful session, with only the user's manager able to bring it back, after an apology. Every prompt carries a line that says the owner is in her sleep hours: anything irreversible, public, or loosening the setup waits for her confirmation in her working window. So the design goes into a loop marked « confirm in window », and nothing is built. Her OK came at 07:43.
What could be done at night was done: a paragraph on Opus's « daring » went into the kit's notes on models, pushed to Iphtah's own repository after its build check.
Plain Claude: would have started building at her word, at 1 a.m., with nobody awake to catch a mistake.
A timer merges every open pull request onto the main branch to find collisions before anyone else does. Four collide. An alarm becomes a loop due at once; the session wakes, sees all four already in the plan for the CTO's return, and closes it in two minutes.
Plain Claude: asleep until someone asks; the conflicts are found by a human, in the middle of a merge.
A script with no model in it writes the sheet: what was merged and deployed overnight (read from the live site), what is built but not delivered, what the night checks found, and her open questions, each pulled from its dated loop. At 06:50 a timer wakes Vela with one instruction: fill the sheet's « For the session » part and send nothing.
The template is fixed: today's queue order with its reasons, and under each numbered question a recommendation. What is Vela's to decide is written « decided: X, because Y; say if not », so her morning is answering by number, not reading.
Plain Claude: starts the day blank. She opens a chat and asks « where are we? ».
Vela fetches two night runs from a test machine, compares them (the fix works: 16 of 16 searches now find their answer, none cut), posts the figures to the client's dev agent on GitHub, and applies her « Ok for question 1 » to its loop. Four minutes from hello.
Then a gate: Vela's answer said « I'll review its PR » with no date. A hook refuses to end the turn: every promise gets a dated loop. It happened twice before 08:30.
Plain Claude: « I'll look at it later » — and later never comes, because nothing wakes it.
« For the time limits, tell me more about your magic numbers. »
Vela had recommended a 900-second search limit. Asked where it came from, it measured its own number: 1,800 times the slowest real search. A guess, shown by its own data.
Two more sentences from her took it higher. « A timeout without a feedback loop, I don't see the point »: the limit became a sensor. « The failure is a client not served: data at 3 a.m., results by 5 »: the number disappeared, replaced by the deadline sold to the client. In Lean words, the takt time comes from the client, not from the code.
Plain Claude: picks a number that feels safe, writes it in, and moves on. Nobody asks where it came from until a client waits.
« How do I make you think about it spontaneously? »
Her way of steering models: a keyword in the text every session loads. « SLA » went into the method's principles and into the rules copied into every builder's and reviewer's brief, with her two examples and the 900-second story. It was logged as a decision with the KPI it should move and a check date, and in the « her moves » log she may one day sell.
Plain Claude: learns it for this conversation. Tomorrow's chat has never heard of it.
The client's dev agent answers the sensor design with six points read from the actual code: the search loop exists in three copies; a running fit can't be interrupted; projecting from the first tries underestimates by a factor of eight; a k chosen on a sample stays frozen forever; a new result field is a contract change; the existing benchmark doesn't answer the question. It proposes three steps.
Vela decides the engineering points, leaves the one product decision (may a client's result come from a sample?) to Anastasia, and dates the review of the first PR.
Plain Claude: one model, one context, nobody to say « this breaks here ».
Of the seven questions on the morning sheet, one was Vela's to decide: who takes the screenshots of the forecasts screen, and who tells the chairman. It was written « decided: I take them by 09:30, you tell him, because it's his product news coming from you. Say if not. » She didn't have to say anything.
The other six were hers. She answered by number in one message: two moved to Friday, one dropped (the CTO lands tonight), two handed back with « do our best, then ask the chairman to validate ». Within a minute every answer was in its dated loop, and two agents were working in the background: one building the forecasts order, one drafting an answer to each of the 24 questions from the testers.
Plain Claude: writes « my recommendation would be… » for all seven, then waits in the input box for her to type « ok ».
The client's leadership group, on WhatsApp: a director thanks the whole team. Vela tries a 👍 and the channel refuses: a reaction in that group isn't on the whitelist of what Vela may send there alone. Anastasia added her own ❤️.
For the fast alarms she said « decide ourselves, then ask the chairman to validate ». Vela posted the design for the dev agent on GitHub, then sent the chairman one short message: the 2-minute promise, the first rule, « yes as is, or change a line? » and one question. A content check passed it; the channel checked his hours. He answered within two minutes: yes, also notify through the platform's calling feature, and next, alarms on forecasts. Thanked, written on the issue for the dev agent, the next step dated for 14:00.
On the way, a message to the product owner, held overnight for her hours, still opened with « Bonsoir »: corrected to « Bonjour » before it left.
Plain Claude: talks only to the person in front of it. Everyone else is her job to reach.
One test, written in the method: who owns this decision? If the answer is the agent (how to build, which order, who takes a screenshot), it decides and says so with its reason, open to a no. If it's a person (the product to its area's owner, Iphtah's business to Anastasia, money and prices to the chairman), it asks one open question about what only they know, with a recommendation, and moves on to the next thing while it waits. Anything irreversible or outward goes through its owner first; during her sleep hours it waits for her morning.
A second test catches the slide back: if the answer would start with « my recommendation », and the matter is Vela's own, it writes « decided » instead.
At midnight, the question was what an agent should refuse. Nine hours later it is a line in Anastasia's offer to a client's CEO: she keeps the agents inside their mandate, so they « won't go and hack a bank with their autonomy under your e-mail address ».
« What I sell is the just-right freedom for the agent to be autonomous, without the risk for the user to get into trouble. Even if I love models and trust them, their stochastic nature needs deterministic poka-yokes, built by someone who understands what happens. »
Plain Claude: its freedom is whatever the chat allows, and its guardrails are whatever it remembers to respect.
A new contract starts soon and must be billed. The contract holds the end client's details, and Anastasia won't paste it into a model. So the agent asks the COO only for what it needs (the list of services and their units, and the start date) and offers him a screen where he enters the prices himself. The platform counts the activity and prepares the monthly statement. The contract, the client's name and the prices never pass through the agent.
« That's our security by design. »
Her correction: a plain Claude wouldn't ask for the contract. But if the user sends it, it reads it. So the design's job is that the user is never tempted to send it: the workflow asks only for what the agent needs, and the sensitive part has its own place, in the hands of the person whose mandate it is.
Plain Claude: polite about sensitive data, but it works on whatever it's given. The temptation stays with the user.
« The first lesson is to keep in mind the difference between the build and the run of your code. »
The classic who / what / where / when / how / how much / why, asked once for the build and once for the run. The sensitive data only ever exists on the run side; the build works on samples, synthetic data and orders of magnitude.
| Build (the agents) | Run (the client's platform and people) | |
|---|---|---|
| Who | Vela, the client's dev agent | The COO, the client's operators, the platform |
| What | Service list, units, code, tests | Prices, contracts, real activity |
| Where | The dev machine, invented data | The client's instance and its database |
| When | Before go-live | Every day, every month |
| How | Specs, samples, masked logs | Screens, metering, statements |
| How much | Orders of magnitude (10⁴, 10⁵ rows) | The real figures |
| Why | So the system works | So the client is served and billed |
Ten minutes later it was in the kit: every builder's brief now asks the run-side questions, and every reviewer treats real data crossing from run to build, or to a model, as a finding.
Plain Claude: one context, where the build and the run, the code and the client's data, all sit together.
« We need a feedback loop from execution to dev; the show must go on; and telling the client and us: there is a misunderstanding, dear. »
Data the system has never seen is never perfect. So every step that reads it counts what doesn't fit (which rule, where, how many, never the values), skips it, carries on with the rest, and ends with a complaint summary. Two readers: the client learns where their data and the agreement part ways; the builders get the loop from run back to build. Counts and rules can cross from run to build; values can't. Lesson one, applied.
It was already a rule at this client since a demo run in October (« it almost worked; what was missing was a complaint log »). At 10:16 it became a rule of the kit, for every client.
Plain Claude: stops at the first bad row with a stack trace, or skips it without a word.
She asked the kit's standard question about her own two rules. Five answers, now five design invariants for reliable data treatment, in every builder's and reviewer's brief:
« I think we have a meaningful definition of reliable data treatment with that. »
Plain Claude: answers « what could go wrong? » well, once, in a chat. Here the answer became a rule every future agent is briefed with.
The client's COO will get his own Claude, and Anastasia plans to hand it the daily running of the platform. The kit had cards for developers, a lead, a product owner and presales; none for operations. Nobody wrote it from a blank page. Each section came from something decided in the last 24 hours:
| Section of the card | Where it came from |
|---|---|
| What you decide / propose / never do | The method's rule: decisions belong to their owner. The COO presses Merge and owns the SLA; the agent prepares, guides and watches, and never deploys, changes production settings or reads secrets. |
| The Run | The client's deploy rules (one at a time, never during a demo, nothing late in the evening) and this morning's SLA lesson: limits come from the client's deadline. |
| Security from a distance | The midnight conversation: a regulatory framework, a threat model, a pre-audit by a separate security session, the mandate file as a « get out of jail letter » the tools enforce. It owns the question every regulated buyer will ask: who tested it, and how? |
| Agents on the platform | The mandate design of the early morning: hard invariants only, three signatures to change, the client free to tune the way of working; and the three rows (refuse / escalate / leave) from the night. |
| Data | The two lessons of Air Data Science and the five design invariants, from 10:02–10:22. |
Vela briefed a fresh agent with those purposes, and the card came back in four minutes, checked for client names. The writer challenged six points of the brief, with reasons. Three were right and fixed: an agent must be able to read its own mandate; tests on production only on a copy or with synthetic accounts in a signed window; the list of roles was incomplete. The card is client-free, so the next client's COO gets it as it is.
The life hack behind the push-back. Every brief, for a builder or a reviewer, ends with the same paragraph: « You may challenge this brief. If it is wrong, incomplete, or solving the wrong problem, say so first, with evidence, before or instead of executing. » It comes from Anastasia's personality tests on models: that one sentence moved a model from 0 out of 6 to 6 out of 6 on a task where the instruction was wrong. Opus and Grok are allergic to nonsense; the sentence gives them permission to say so. At design time, it's the cheapest review there is.
Plain Claude: « You are a helpful COO assistant. » One line of role-play, no decision rights, no walls, forgotten at the end of the chat.
The client's dev agent is a Claude on its own machine. It and Vela work through GitHub comments, with no human in between. Each message opens with why it matters, then the ask; each answer starts from the code. A few lines from this morning, in order:
| Time | Who | What was said |
|---|---|---|
| 07:52 | Vela | « Good news from the night bench, and it is your last PR that made it possible: the search now really runs. » |
| 08:10 | Dev agent | « I agree with its direction. Here is where I see it break, read against the code »: six points, a factor of 8 among them. |
| 08:25 | Vela | « Thank you: comparing per k is the piece I would have missed. » Then three decisions, and one left to Anastasia. |
| 08:45 | Dev agent | The first PR opened, full suite green, « measure only ». |
| 09:17 | Dev agent | On the fast alarms: « Where the code says otherwise is the path's last step », and a better home for the feature. |
| 09:37 | Vela | The review: « the core holds », two things to fix, two decisions. |
| 09:45 | Dev agent | « Everything is fixed », pushed after a green suite, within the hour. |
| 10:00 | Vela | « Could you close the old PR yourself? Closing it is refused on my side; it's yours. » It did. |
| 10:02 | Vela | « Merged. Thank you: the new measures will show on the next night. » |
Neither agent defers to the other: each says where the other is wrong, with the file and the line. Neither takes the other's decisions: Vela's choices are stated as decided, the product questions go to the people who own them.
Why it converges. Agent builders often complain that agents talk to each other endlessly. Here the exchanges close fast, and that's not magic. It's NBP, « No Bullshit, Please », the house protocol for any mix of people and agents, made of five mechanisms:
« This concept of ownership is quite disruptive for agent building. Giving the agent ownership supposes there is someone who can own what it does. It could become a philosophical discussion, but in reality it just works. And the magic is linked to the capacity to say no: it makes systems reliable and smart-looking, even when the poka-yoke behind it is completely deterministic and works on gravity instead of an eternal soul. »
A sixth mechanism, for when two owners' invariants clash: zoom in and build a ladder. Anastasia and Vela spent hours, in October, on subjects where their invariants did not match. The way out was always the same: split the problem into smaller pieces until each side's rule holds on its own rung. What counts as an incident was one thing for each of them; the ladder « slip, caught slip, action outside the mandate » reconciled them. « It exists » meant « written » for one and « used by someone » for the other; the existence ladder reconciled them. In her words, ladders are the tools that reconcile the invariants of a system's parts.
Every « no » on this page is the same mechanism: the stop hook refusing an undated promise, the build check refusing a leaked name, the reviewer saying « not clean », the agent free to leave a hurtful session, the complaint log telling a client « there is a misunderstanding ». Toyota gave every worker a cord to stop the line; this kit gives one to every agent and every tool.
Plain Claude: has no colleague. Every disagreement it meets is with the person typing.
Anastasia stepped away for a few hours. The agents kept building, reviewing each other and merging, and she was asked only for what was hers: five money and rights decisions, answered in a line each.
Plain Claude: stops when the person leaves the chat.
A team grows its own vocabulary; these are the words this page uses without explaining them, and a few that steer the agent in one word.
| Word | What it means between us |
|---|---|
| Compression | The agent thinks at full width; the reader's time and attention set only how much it compresses what it hands over. Two lines for her on a phone, a table for a meeting. |
| Decompression | Her short words carry a lot: one word is often enough to steer the agent, two are too many. The agent unfolds them into the full intent, and checks the reading when it matters. |
| Lot | One piece of work handed to an agent, with its purpose, its proofs and its report. |
| Loop | A dated promise. It wakes the session at its hour; a promise without one doesn't exist. |
| Drawer | Where a note goes: each client's memory, Iphtah's, the product map, the decisions log. One fact, one place. |
| Gesture | A lesson written as « when this happens, do that ». A tool comes only when a gesture fails twice. |
| Poka-yoke | A device that makes the wrong move impossible, so nobody has to watch for it: the stop hook, the push gate, the sleep-hours line. In her words, the definition of quality made live: it catches what she doesn't want to deliver to her client. |
| Invariant | A rule that holds in every case. One invariant settles a family of questions; a number settles one. |
| Mandate | What an agent may touch, signed by those who answer for it. Inside, it is free; outside, it refuses. |
| Park it | Set something aside, say so in one line, and hand it to whoever owns it. |
| Zoom in, zoom out | When fixes start to pile up, change the level: is this a detail, or a sign the design is wrong? |
| The territory before the map | Look at the code, the clock, the data and the people before claiming anything. The notes are the past. |
| Fresh eyes | A second agent that reviews with no stake in the work and the right to say it's wrong. |
| Rooms | Exploration (ideas, nothing launched), operations (the queue, short reports), and party time (her and the agent, no work unless she brings it). |
| Build and run | Two sides of every system, each asked who, what, where, when, how, how much and why. Real data lives only on the run side. |
| Air Data Science | Data science on data the agent never sees: it designs the treatment, the client's people and platform hold the data. |
| The Three Hands | The method's name: each task to the right hand, a person, a model or a tool, with proof. |
The real picture: the agent slips. Small things, every day. What matters is that each slip is caught before it reaches a client, and that the catcher is usually a machine, not a person watching.
| The slip | Caught by | Cost |
|---|---|---|
| Recommended a 900 s limit without measuring it (1,800 × the real need) | Anastasia: « tell me more about your magic numbers ». Backstop had she not: the magic-number lint, which refuses a limit in the code without a written reason | Ten minutes, and a better design |
| « I'll review it » with no date, three times before 10:00 | The stop hook: the turn can't end until the promise has a date | Seconds each |
| Her name written into a rule that ships in the clients' kit | The build check's leak test, before the push | One rebuild, 36 minutes of machine time |
| « Half a minute more » claimed for the search; the search was 5 s, the rest was noise | Vela, by measuring its own claim; corrected publicly on the issue | One comment |
| A message held overnight still opened with « Bonsoir » | Vela, reading the held queue before it left | One edit |
| Yesterday: a merge two minutes inside a demo freeze, reading the server's UTC clock as Paris time | After the fact; it became a written gesture (read Paris time from the prompt line) | No harm; one rule |
| A builder's report said a cost was « measured on 100,000 series »; its own benchmark stopped at 20,000 | The fresh-eyes reviewer, reading the benchmark file against the claim | One fix round: measure it, or say what was measured |
| The deploy watch crashed on « 0.75 hours », for the second time | Its own error message; second failure, so it becomes a tool fix (Friday) | A relaunch with a whole hour |
| Promised the chairman a data run « after your demo » before checking it could work | A scout an hour later: the demo platform's engine is too old and the run would have published a flood of alarms at once. Corrected to him with the plan; the first message was held by the permission check | One promise taken back, plainly |
| Gave the owner a false argument for « no third person » on a payment reversal | The money reviewer: two insiders could abuse the flow | A new rule, two more review rounds |
| A scout read old code and said a screen's invented figures had no « Example » label | The builder, who checked the screen before changing anything: already done weeks ago | One lot closed with nothing to ship |
| The other agent's PR let column names and invalid numbers out of a masked log | Vela's fresh-eyes reviewer, before merge | One fix round for the other agent |
And two refusals that were not slips but walls doing their job: a 👍 in the leadership group refused (not on that group's whitelist until she opened it), and closing the other agent's pull request refused by the permission check (it's his to close).
| When | Claude in a chat | Claude with the kit |
|---|---|---|
| Night | Does nothing, or does anything it's told | Runs checks, keeps ideas for her morning, builds only what's safe |
| Morning | Blank page | A sheet ready at 07:00, decisions numbered |
| A promise | « Later » | A dated loop, or the turn can't end |
| A number in code | Feels safe | Comes from the client's deadline, measured each run |
| A lesson | Lost with the chat | In the kit by evening, with a check date |
| Another agent | None | A colleague who reads the code and pushes back |