Build your company’s AI brain

Interview me to list every repeat job in my company. Ask one question at a
time, department by department: sales, support, operations, finance,
marketing, admin.

For each job, get: what it is, who does it, hours a week (my best guess is fine;
mark it ESTIMATE), and how repeatable it is, from 1 (different every time) to
5 (the same steps every time).

When I say "done", return a table sorted by hours a week, with the total hours
a week. Then the yearly cost at [your hourly cost] an hour, labelled MODELLED,
because the hours are estimates.

Here is my job table: [paste the table from B1]

Sort the jobs into three groups:
- AI first: [hours threshold, e.g. 8] or more hours a week and repeatability
  4 or 5.
- AI drafts, a person decides: above the threshold and repeatability 1 to 3.
- Stays with people: under the threshold.

Then pick the single first job for an agent: the one with the most hours in
"AI first" where a mistake can be caught before it reaches a customer.
Say why, and say what could go wrong.

Write the job card for one AI agent doing this job: [the job from B2].
Fill in each line. Write UNKNOWN where I haven't told you, and ask me for those
at the end.

- Trigger: what starts it.
- Inputs: exactly what it reads, and from where.
- Steps: numbered, in plain words.
- Checks before anything leaves it: write each as a yes/no rule. For example,
  for replying to an enquiry: no price in writing; both offered times are still
  free; the name and job match the form; nothing is promised that the team
  can't do.
- When a check fails: who it hands off to, and how they are alerted.
- Output: what it produces, and where it is saved.
- Verifier: how a person or a test can tell the output is right without
  trusting the agent.
- Permission: draft only, ask first, or act alone, and what would move it up a
  level.
- Budget: a cost cap per run and per month.
- Kill switch: how to stop it in one step.
- Never: actions it may never take on its own (sending money, changing prices,
  deleting records, anything else I list).

You're setting up the files every AI agent in my company reads before it acts.
Interview me first, one question at a time: what the company does; the goal and
the deadline; the offers (no prices needed); who decides what; the tools and
where our data lives; the rules that must never be broken; what's in flight
right now.

Then write three files:
1. RULES.md (name it CLAUDE.md if you are Claude Code): the goal in one line;
   "Read in this order, then stop": a numbered list of no more than five files;
   the folders and who may write in each; the rules that override defaults
   (never invent a number, write UNKNOWN; never send, spend or change a price
   without a person; one company per task).
2. NOW.md: at most 500 words: what is true right now, what is in flight, what
   is waiting on me, and the next three moves. It is rewritten at every
   handoff, never appended to.
3. INDEX.md: one line per page or folder: the path, what it holds, and when to
   read it.

Keep each file short. If I haven't told you something, write UNKNOWN. Don't
fill gaps.

I'm giving an AI agent the job of [replying to new leads / answering customer
questions]. Build its knowledge pack as seven short files. Interview me for
each one, one question at a time, and use only what I tell you or paste in.

L1 Voice: how I talk. 10 to 20 lines I actually wrote, each with where it came
   from, and words I never use.
L2 Offers: each offer, who it's for, and what happens next. No prices unless I
   say they're public.
L3 Buyers: who we serve and who we don't, and the questions that tell them
   apart.
L4 Selling: the diagnosis questions, the common objections and the answers I'd
   give, and how to book (offer two specific times).
L5 Claims: the only facts the agent may state, each with its source. Anything
   not in this file, it may not claim.
L6 Rules: numbered rules, and exactly when to hand off to a person, written so
   a program could check them.
L7 Learnings: empty for now. Each time I correct the agent, the correction
   becomes a dated rule here.

Precedence: L6 beats everything. L5 beats L2 to L4 on what may be stated.
When the pack doesn't answer, the agent hands off. It never fills the gap.

Then write 20 test messages, including 5 hard ones (price questions, an angry
customer, "are you a bot?", a request outside our service), and what a correct
reply does for each.

Before anything goes into the pack, remove every password, key, personal phone
number and personal email.

Build a monthly P&L for each AI agent I run. Here is what I have, per agent:
[runs; cost from provider bills or logs; hours of my team's time it saved
(estimate); revenue you can trace to its work (only if traced)]

For each agent return:
- runs;
- cost: MEASURED, from bills or logs;
- hours back: MODELLED, an estimate;
- value of those hours at [your hourly cost]: MODELLED;
- revenue credited: MEASURED, only where a sale traces to the agent's work;
  otherwise 0;
- net: revenue plus modelled value, minus cost, with the basis stated.

Then apply my rule: [your rule; for example: grow its budget when its 30-day
return is positive, halve it when negative, pause it at 60 days negative].

List the agents that have no cost record. Missing cost is UNKNOWN, not zero.

Write a routine file that an AI agent will run on a schedule while I'm away.
The job: [one job, e.g. "build tomorrow's call list from yesterday's new leads"].

Sections:
- Name and schedule: when it runs, and the longest it may take.
- Reads: the exact files or tables, nothing else.
- Does: numbered steps.
- Writes: the output file and where it goes, plus the log line it adds.
- Done when: a result a person can check in one minute.
- Verify: a check that doesn't need AI (a count, a file exists, a test passes).
- Budget: the maximum cost per run; stop if it's reached.
- Never: no sending, no spending, no price changes, no deleting. Anything like
  that becomes a draft for me to approve in the morning.
- On failure: retry once, then leave me a note and stop.

Keep it under one page. The routine file is the instruction: to change what it
does, change the file, not the prompt.