Ali Hamou

Playbook 06

How I put AI to work

Which model gets which job, what a run costs before it starts, the check before anything ships, and where AI hands over to a person.

For sales teams, operators and founders who run real work on AIRead 8 minutesIncludes a routing cost calculator

The short version

  1. Choose the model for the job, not out of habit.Judgment goes to a strong default model. The top tier is for a task I can name. Mechanical work goes down a tier.
  2. Price the run before it starts.A run costs its context multiplied by its turns. The question itself is almost free.
  3. End the run at the task boundary.State goes to a file and the next task starts clean. It is the one saving that gives up nothing.
  4. Nothing ships without a written check.A list of pass or fail lines, run by something other than the model that wrote the work.
  5. AI stops where an action is external and cannot be undone.Sending, publishing, spending and promising wait for a person. So does the conversation with the customer.
01

Choose the model for each job

I am an Account Executive. My hours belong with customers, so the work around a deal runs on AI in the background: research, drafts, follow-ups, reporting and the software behind them. That only works when each job lands on the right model.

I route with one question: what does a wrong answer cost, and who would catch it? If a mistake costs money or reputation and nobody would notice, the job needs judgment. If the output is easy to check, the job is mechanical.

The jobModelEffort
Judgment: pricing, offers, positioning, a proposal, anything sent under my nameThe strong defaultHigh
The hardest work: a build that runs for hours, a bug that already beat the default, a plan across many systemsTop tier, chosen by nameHigh
Mechanical: formatting, data cleanup, file changes, batch edits from an approved specFast tierMedium
Reads a lot, decides little: research sweeps, log reading, fetching documentsFast tier, as helper agentsLow

Effort, how hard the model is told to think, is the second dial. Reasoning is billed as output, the most expensive token there is: in my own usage, output is 0.5% of the tokens and 15% of the cost. Mechanical work does not get deep reasoning.

  • Start on the default. Go up by name. If I cannot say why the default would fail, the task does not go to the top tier.
  • Go down when the judgment is done. The rest is execution. Start a clean run on the cheaper model and paste the decision in. Switching models in the middle of a long run bills the whole conversation again.
  • Go up on the second failure. A cheap model that fails twice does not get a third attempt.

Example. A proposal. The pricing logic and the argument run on the default model at high effort. Turning it into a 1 page summary and a follow-up draft runs on the fast tier. The expensive model only touched the part where a wrong call costs money.

The mistake: the smallest model on anything with judgment. The saving holds until the first wrong price goes out. The opposite mistake is the top tier on a mechanical task "in case it gets hard": you pay the top price for every token, rereads included.

02

Price the run before it starts

The cost of AI is not in the question. The question is almost free. What costs money is context: on every turn the model reads the whole conversation again, with the instructions, the tool definitions and every file it opened.

A run costs its context multiplied by its turns.

Example, with round numbers. A run of 60 turns that starts at 30,000 tokens (about 22,000 words) and adds 3,000 a turn. To write 30,000 tokens of output, the model rereads 7 million. Split the same work into 2 runs of 30 turns and it rereads 4.4 million. The calculator opens on this run.

I measured my own usage across about 2,000 recorded runs:

  • 85% of the cost was context. 53% was rereading it, at the discount providers give for text the model has already seen (the cache). 32% was writing it into that cache: new material once, and all of it again after a long pause or a model switch. The output was 15%.
  • 10 runs were 24% of everything I have ever used. All 10 ran past 800 turns.
  • File reads were 73% of everything my tools put into context. One file read averaged 41,000 tokens. One shell command, such as a search, averaged under 800.

What I do about it:

  • End the run at the task boundary. Write the state to a file, clear the context, start the next task clean. Clearing is free.
  • Close the run before stepping away. The cache expires in 5 minutes to an hour. The first message back bills the whole context again at the write price, more than 10 times the price of a reread.
  • Search for the line. Do not load the file. Load big material late, so it rides along for fewer turns.
  • Connect only the tools the job needs. Every tool and instruction file is reread on every turn. My median run starts at 36,000 tokens before I type a word.

The mistake: one conversation, all day, across unrelated tasks. It feels efficient. Turn 300 costs many times what turn 10 cost, for the same work.

03

Plan on the stronger model, build on the cheaper one

Deciding what to do is the expensive part. Doing it is cheap once the decision is on paper. So I split them.

  1. The stronger model writes the plan to a file: the goal, the files it touches, the steps, the checks, and what done looks like.
  2. The context is cleared. The plan file is the handoff, not the conversation.
  3. A cheaper model executes the plan, step by step.
  4. A reviewer with a clean context checks the result against the plan. The model that built something is the worst one to judge it.

Parallel agents are for work that is wide and cannot be scripted. Example. When I rebuilt this website, 3 phone testers, a desktop tester and a code reviewer ran at the same time and returned 70 findings. All of them were fixed in 2 rounds.

The mistake: sending agents to do what a script could do. Every agent loads its own starting context first, so 10 agents is 10 startups.

If a script can answer the question, write the script.
04

Nothing ships without a check

AI makes wrong work as easy to produce as right work. Reading all of it myself does not scale, and asking the model "is this right?" is not a check. It says yes.

A check that works has 4 properties:

  • It is written down. A list of pass or fail lines. "Review this" is not a check.
  • Something else runs it. A script where a script can decide: banned words, broken links, the totals on a quote, the build. A second model with a clean context where it takes judgment. Never the model that wrote the work.
  • It runs every time, asked for or not, on the thing as it will ship: the email with its signature and footer, not the draft body.
  • A fail blocks. It does not warn.

I also test the check. I feed it work that should fail. If that passes, every clean result before it meant nothing.

Example. The check I would start with. Run it in a new conversation, not the one that wrote the draft.

Check before anything goes to a customer
Check the draft below before it goes out. Answer PASS or FAIL for each line and quote the exact words that failed. Do not rewrite anything.

1. Every number, price and claim is in the notes. List any that is not.
2. No name, quote or personal detail that is not in the notes.
3. It promises no date, price or result I have not approved.
4. One ask. The reader knows exactly what to do next.
5. Plain words. No filler opening, no hype.
6. It agrees with the last message this person had from me.

If any line fails, stop and show me the failures.

NOTES: [paste what is true]

DRAFT: [paste the draft]

One rule sits under every check: never invent. No made up price, statistic, name or quote. A model that does not know says so.

The mistake: letting the author grade its own work, and trusting a check you have never seen fail.

05

Where AI has to stop

Inside my own files the system acts without asking. Outside them, a short written list waits for a person.

AI does it aloneA person first
Research and analysisSending anything to a customer or a prospect
Drafts of anythingPublishing anything public
Building and testing softwareSpending money, every time
Organizing files and recordsCommitting me to a person, a date or a price
Reading live ad and sales dataChanging anything live: a budget, a launch, a record in a system I do not own

The test is 2 words: external and irreversible. A draft can be fixed tomorrow. A sent email cannot be recalled.

3 kinds of work always go to a person:

  • The sales conversation. Discovery, the demo, the negotiation, the close. AI prepares the call and logs it afterwards. The call is mine.
  • Facts that live in someone's head. What the customer said, what was agreed on the phone. The system asks. It does not guess.
  • Changes to anything live. My ad automation is read only: it checks the account every day and reports each problem with what it costs to leave it. Campaigns are built paused, and a person starts them.

The mistake: approving by category. "You can send follow-ups" becomes a message you never read, sitting in a customer's inbox. A yes covers one action, not the next one like it.

I set the direction. The system does the work. Nothing irreversible happens without a person.
06

State lives in files

A model forgets everything when the run ends. The conversation is also the most expensive place to keep a fact: I pay to reread it on every turn, and it is gone when I clear. A file costs nothing until it is needed.

So every decision, number and rule goes into a file the moment it is made, with the date.

Example. Every run ends with a note of 5 lines: what was done, where it stands, the next move, what it is blocked on, and what not to redo. The next run starts from that note with a clean context. The templates are in How I manage multiple tasks and workflows.

The mistake: using the chat history as memory. It is the one store you pay for on every turn and lose at the end.

The calculator

Price a run. Then route the month.

Describe one typical run and see what it costs on each tier before you start it. Then see what routing a month of those runs saves. Every price is an input. The defaults are the list prices of the 3 models I route between (Claude Fable 5.2, Opus 5.5 and Sonnet 5.5) as published on 10 November 2026. Prices change, so put in your provider's.

The run1,000 tokens is about 750 words

Prices, US$ per million tokensReread is the cached input price

Top
Default
Fast

The month

A runA month
All on the top tier$0$0
All on the default tier$0$0
All on the fast tier$0$0
Routed$0$0
Routed, each run split in 2$0$0
Saved a monthagainst all on the top tier$0

What this assumes. Every turn rereads the whole context at the reread price. New tokens are cached once at the cache write price. Output includes reasoning. Context stops growing at 1,000,000 tokens. A split run starts its second half from the same starting context plus a 2,000 token state note. A long break bills the context at that point again at the write price. Every run in the month has the same shape, so price your 3 most common runs one at a time. Not included: batch discounts, long context surcharges, tool fees and failed attempts. No caching on your setup? Set Reread equal to Input and Cache write to 100.

Start this week

  1. List the jobs. Every recurring task you give AI. Mark each one judgment or mechanical.
  2. Write the routing rule. One default model, what goes up by name, what goes down.
  3. Price your longest run. Put last week's longest run in the calculator. Next time, end it at the task boundary.
  4. Write the stop list and one check. Start with whatever reaches customers.
  5. Read your usage page. Find the 3 most expensive runs and ask what made them long.

What this is built on

I never stop learning. This playbook is built on the people below, then tested in my own work.

  1. Anthropic, Building Effective AgentsStart with the simplest setup that works, and add steps only when they earn their place. When the path is known, a plain workflow beats an agent.
  2. Anthropic’s Claude Code and prompting guidesClaude Code is the tool I build with most. Their guides shaped how I write instructions: clear, specific, with examples and a check on every output, like a brief to a new hire.

Want to compare notes on running AI? Message me on LinkedIn.

I am an Account Executive first. This system runs in the background so my hours go to customers.

Ali Hamou · London, Ontario · Usage figures are from my own logs, measured on 10 November 2026, with cost weighted at standard cache prices: a reread at 0.1, a cache write at 1.25 and output at 5 times the input price. Default prices in the calculator are list prices on that date. Yours will differ.