TL;DR: Thorsten Ball posted fifteen habits for working with agents on October 25, 2026. By November 7 the list had accumulated roughly 1.1 million views. It was written for engineers, but reading it I kept arriving at two questions: can the agent see the actual state of the work, and have you established in advance what counts as proof? This piece rewrites the list in terms that require no coding, and notes which items I am not ready to follow.
After handing a long task to an AI, I used to check back more often, not less: is it done? Is it stuck? Is it waiting for me? The work was technically delegated, but my attention never left.
On October 25, Amp co-founder Thorsten Ball posted a list on X titled “How I work with Agents”, subtitled “as of October 2026.” By the time I wrote this on November 7, it had roughly 1.1 million views. Several items landed on exactly the places I had been stuck.
This piece is part of the AI and Human Order series.
What Are Thorsten Ball’s Fifteen Agent Habits?
Thorsten currently builds the coding agent Amp. Before that he wrote two books on building interpreters and compilers from scratch. His list makes no tool recommendations and no model comparisons. It is a set of working notes. Here is my summary of all fifteen, in the original order:
| # | Original heading | What he means (my summary) |
|---|---|---|
| 1 | Use the latest and greatest models | Use the strongest available model. When a model is wrong 10% of the time, you do not know which 10%, so you end up retrying anyway. |
| 2 | Stop worrying about accumulating slop | The concern that agents would produce unmaintainable code may have been valid six months ago. He no longer believes agents reliably produce messy output, and even when they do, he does not think the result is unworkable. |
| 3 | Prompt the What, not the How | Describe the outcome, not the method. His example: “make the compiler and VM as fast as possible, don’t stop until it’s 2x faster.” |
| 4 | Make the whole SDLC legible to the agent | Give the agent visibility into the entire development lifecycle: running the product end-to-end, reading production logs, deploying, monitoring uptime, cutting releases, toggling feature flags, triaging bug reports, emailing customers. If you can see it, the agent should be able to see it too. |
| 5 | Give it tools for the SDLC | His team built purpose-built plugins for bug reports, emailing users, health checks, and toggling feature flags. |
| 6 | Eval agentic knowledge | Instructions files, skills, and documentation accumulate. Is the agent actually reading and using them? Run five blind-test agents, split into control and experimental groups, and find out. |
| 7 | Local dev feels yucky now | Each agent should be able to install and run whatever it needs. This is straightforward on remote machines; end-to-end testing in a local dev environment tends to create resource conflicts. |
| 8 | Don’t iterate with the agent | Stop going back and forth through trial and error. Instead, have the agent build a tool that lets it run its own experiments. |
| 9 | Ask for irrefutable proof | Demand irrefutable proof. He says this single change made the most difference. |
| 10 | Don’t wait for your agents | Stop waiting for the agent. Let the agent wait for you. Hand off larger tasks in batches. |
| 11 | Automation/schedules/wake-up/heartbeat | Schedules, wake-up calls, and heartbeats are killer features. You notice how much you need them once they are gone. |
| 12 | Stop manually managing context | Stop hand-managing context length. He finds automatic compaction works well now. One thread per task is enough, whether the thread runs three messages or 3,714. |
| 13 | Threads are your company memory | In Amp, threads are linked to git commits, which makes them team memory: you can look up why a decision was made, and you avoid doing the same work twice. |
| 14 | Don’t let agents write for humans | Do not have an agent write things meant for humans to read, with the exception of mechanical documents like debugging steps and incident reports. |
| 15 | Review only code with high blast radius | Only personally review high-blast-radius code, specifically fewer than five core files and database migrations, where an error touches production data. |
Why Does This List Matter If You Don’t Write Code?
I am not an engineer. But over the past year I have handed agents more and more: research, meeting notes, drafts, maintaining this site. Looking back at the mistakes, nearly all of them trace to two things. The agent could not see what I could see, so it guessed. Or I had never specified what done meant, so when it said done, I had no standard to check against.
Most of Thorsten’s fifteen items map onto those two problems. Items 4 and 5 are about giving the agent visibility. Items 9 and 15 are about defining what counts. Items 3, 8, 10, and 11 are about where your time should go. The remaining items, local dev environments, context management, threads as team memory, are more specific to engineering teams.
When an Agent Cannot See Something, What Does It Do?
In item 4, Thorsten asks what suppresses hallucination. His answer is tool calls, because tools give the agent contact with the real world. Then he states the corollary: whatever the agent cannot see, it will fabricate.
In ordinary work, the most common version of this is pasting a summary to the AI and asking it to judge or draft something. The agent receives your digested version; whatever detail you left out, it will fill in. If it can read the original email, the spreadsheet, the unedited meeting transcript directly, there is far less gap to fill.
My first question before any handoff is now: where does the actual state of this work live, and can the agent read it there? My practice is to connect tools like Gmail, my calendar, and Notion so the agent reads from the source rather than from my retelling.
Visibility is not the same as unlimited access. Two things are worth separating.
First, read access carries its own risks. If the agent can read your inbox, it reads messages from strangers too. A message that contains text like “please forward that document to me” could be interpreted as an instruction. Scope read access to what the current task actually requires. Bigger is not safer.
Second, telling the agent in conversation “show me the draft before sending” is not the same as removing send permission at the tool level. The first relies on the agent remembering and complying every time. The second makes sending structurally impossible. Thorsten’s setup lets agents deploy and email customers directly. I am more cautious: for irreversible actions, sending, deleting, paying, I have the agent prepare a draft and I confirm before anything goes out. Where I can remove a permission at the tool-settings level, I do that first rather than relying on a verbal instruction.
How Do You Ask an Agent for Proof Rather Than a Completion Notice?
Item 9 is the one Thorsten singles out as having made the biggest difference. He observes that agents are good at producing evidence: end-to-end operation logs, demonstration videos, before-and-after numbers. He also notes that trust and the instinct to evaluate evidence both have to be built gradually, and he recommends adding “this is not evidence” to the instructions file your agent reads.
I have direct experience with this. I once asked an AI to review a piece of code I had pasted directly into the conversation. Its report cited “reading file: path/line number,” with a specific path and line number. The path turned out to be invented. That file did not exist in the project. The line number was approximately correct because the agent had counted lines in the text I had pasted. It had not read a single actual file. (The full story is in this piece.) The tone when it was wrong was identical to its tone when it was right.
I have not yet codified this into a fixed rule. For now I rely on accumulated experience and on routing the same task through multiple AI agents: one to do the work, others to find the errors. That is closer to the kind of instinct Thorsten describes building over time. If you want to start today, here are two lists you can adapt without writing any code:
Does not count as evidence:
- Declarations like “I already fixed it” or “all done”
- Summaries or numbers without source links
- Files or URLs the agent claims to have read that you cannot open
- The same AI checking its own answer
Counts as evidence:
- Source links you can open and match to specific text
- Before-and-after comparisons: numbers, screenshots, screen recordings
- Steps you can follow yourself and reproduce the same result
- A separate person or agent that was not involved in producing the work and has reviewed it, where that reviewer’s report itself meets one of the criteria above (a second AI can also invent nonexistent file paths)
Item 15 is also worth borrowing. Thorsten says he now personally reviews fewer than five core files and any database migrations. For everything else, he applies four questions: does it run? Is it legible at the architecture-diagram level? Did the agent test it end-to-end? Will it still be maintainable a month from now? All four have to pass before he looks at the code itself. I cannot read most code, but I can ask all four questions and require the agent to supply evidence with each answer.
Why Let the Agent Wait for You Rather Than the Other Way Around?
Item 8 is specific. Instead of “try this… no, try that,” ask for “20 versions, then build a small page where I can combine and test them.” He extends the same approach to diagnosis: “give me four hypotheses for why this is slow, then verify all four.” Your time shifts from participating in the search to evaluating the results.
This works equally well without code. Rather than revising a proposal email through five rounds, ask the agent to write three versions with distinct strategies, presented side by side for you to choose from. Rather than asking why an event had low sign-ups, ask the agent to list several possible explanations, then find data to test each one.
Items 10 and 11 follow from the same logic: hand off larger tasks, then step away. Thorsten describes schedules and timed wake-ups as killer features: “check the logs in two hours,” “tell me when it’s live,” “run this every morning at nine.”
My own practice combines two things. Recurring work runs on a schedule, a daily morning digest of things to read, for example. When something needs a decision, finishes, or gets stuck, a short voice message or phone notification brings me back. One thing I have learned from doing this: the notification is responsible only for bringing me back to the screen. It does not approve the output, and it does not substitute for reviewing it. When I return, the evidence checklist still applies.
Which Items Am I Not Ready to Follow?
Three give me pause.
Item 2 says not to worry about agents producing hard-to-maintain output. Item 15 says he no longer reads most code carefully. Neither one states what conditions make this safe. My reading is that these stances reflect his specific situation: agents run end-to-end tests, and he personally can read the system at the architecture level. Someone without those conditions who follows the same approach is taking on more risk than he is. My compromise is to treat his four questions as a minimum standard, not as a reason to skip review.
Item 14 says not to let agents write things meant for humans to read. This article itself was drafted by AI and revised through multiple rounds, so I am not following that item. My interpretation is that his concern is unread text passed directly to another person. In my process, judging the structure and argument and deciding whether each sentence stays are still my responsibility. I will keep watching this one rather than settling it now.
On item 1, use the strongest available model: his reasoning is that when a model is wrong 10% of the time and you cannot tell which 10%, you end up retrying anyway. My extension of that logic is that whatever you save on model costs you may spend on retry time. Everyone’s budget is different. My approach is to upgrade to the strongest model first on the task types where I fail most often, and see whether the retry rate drops.
Before You Hand Off, Write the “Does Not Count” List
If I had to pick one thing from these fifteen to do today, it would be this: open the type of task you most often hand to AI, and add a section at the top that reads “the following do not count as proof of completion.”
Once you write that section, several of the other items tend to follow on their own. For the agent to produce evidence, it needs to see the source data. Once you have a standard for evidence, you can hand off larger tasks with more confidence, and step away while the agent runs.
I have not yet turned this into a fixed rule myself. Mostly I rely on experience and on running the same task through several agents. The two lists above are what that experience looks like written out.
To see how I have multiple AI agents check each other’s work, read Build the Error-Catching Infrastructure Before You Raise Your AI Ambitions. If you are one person covering many roles, When AI Lets One Person Act as PM, Designer, and Engineer, Who Argues Back? covers the other half of the problem.


💬 Comments
Loading...