Subagents: let AI manage AI

I want to process [60] items of type [item description] and
do [description of the work] for each one. By hand, I
estimate that's [20] minutes per item.

Assess whether it's worth splitting this across parallel
agents:
1. Are the items actually independent, or do some need the
   result from others? List where you see a dependency.
2. What needs to stay consistent across all the items, and
   is there a risk it drifts apart without coordination?
3. Estimate how long it would take to write instructions
   detailed enough for an agent to handle without having to
   ask follow-up questions.
4. Estimate how long checking the outputs will take.
5. Is it worth it, or should I stick with one agent? Answer
   clearly and justify it.

Be skeptical. If it's not worth it, say so directly.

I'm writing an instruction file for sub-agents who'll be
processing [60] items of type [description] in parallel.
Each agent will only see this file and its own batch of
items — nothing else, and it can't ask me follow-up
questions.

Goal: [what should be produced]
Input: [what the agent receives]
Output: [format, e.g. a CSV row / a .md file / a filled-in
table]

Write a draft instruction file with these sections:
1. Goal and context, in three sentences
2. The exact procedure, step by step
3. Output format down to the last detail (field names,
   order, encoding, date and number format, what to do with
   empty fields)
4. Boundaries: what not to guess at, what to never do, how
   to record uncertainty
5. One example of a correctly filled-in item
6. One example of a bad output and an explanation of what's
   wrong with it

Write it as instructions for an executor, not a description
for a human. At the end, list 10 questions that my brief
doesn't answer and that an agent would have to guess at.

THE UNCERTAINTY RULE (overrides everything else)

If you can't find a value, don't guess at it. Never fill in
a value by estimating, even when it seems “obvious.”

- leave a field blank if it can't be filled in
- in the notes column, write the reason: NOT FOUND /
  AMBIGUOUS / SOURCE UNRELIABLE
- in the confidence column, write high / medium / low
- if you're unsure about an entire item, mark it NEEDS
  MANUAL REVIEW and briefly explain why

Ten blank fields beat one made-up one. A human fills in a
blank field in a minute; a made-up one gets caught a month
later.

Take this instruction file and process a single item with
it: [specific item].

Follow the instructions exactly, don't add anything of your
own.

Once you're done, tell me, in addition to the result:
1. which parts of the instructions were ambiguous, and how
   you interpreted them
2. what was missing from the instructions entirely
3. where you had to guess at something
4. which steps were unnecessary or overlapped
5. how long this procedure would take for 60 items

Be specific and quote the parts of the instructions you're
referring to.

We have an instruction file [path] verified on two items,
and a list of [60] items in [path to list].

Split the work across 8 parallel agents:
- each one gets [7-8] items, following the order in the list
- each agent works strictly from the instruction file
- each one writes its result to its own file,
  outputs/batch-01.csv through outputs/batch-08.csv
- no agent may touch another agent's files, or change the
  source data

Before you start, tell me:
1. which items go to which agent
2. exactly what instructions you'll hand each agent (verbatim)
3. what you'll do if an agent fails partway through

Then wait for my approval.

All 8 batches are done. Collect the outputs from the
outputs/ folder into a single results.csv file.

Don't just concatenate them — do this:
1. check that all the batches have the same columns in the
   same order; list any mismatches
2. verify there are [60] items total and none is missing or
   duplicated
3. list items with blank required fields
4. list items marked NEEDS MANUAL REVIEW, and items with low
   confidence
5. find inconsistencies across batches: different spellings
   of the same name, different date and number formats,
   different units
6. at the end, write a summary: how many items are done with
   no caveats, how many need my attention and why

Don't fix anything yourself, just list it. Keep formatting
inconsistencies separate from content ones.

Write me a QA script, qa.py, that goes through the file
results.csv and reports any problems.

Checks:
1. required fields [list of fields] aren't blank
2. format: dates as YYYY-MM-DD, numbers with no thousands
   separators and a decimal point, no line breaks in text
   fields
3. values outside a reasonable range: [e.g. price below 0 or
   above 1,000,000, a date in the future]
4. duplicates in the [key field] field
5. total row count is [60]
6. items with low confidence or marked NEEDS MANUAL REVIEW
7. values that are written inconsistently within one field
   (variants of the same name)

Output: a clear list of findings, each with a row number and
what's wrong, sorted by severity. A numeric summary at the
end. The script doesn't fix anything.

Then run it and show me the result.

We have [300] items total. I don't want to run this all at
once.

Schedule the work into three rounds of [100] items:
- stop after each round, don't start the next one
- after each round, run the QA script (qa.py) and give me a
  summary of the findings
- after each round, give me 3 suggestions for what to tighten
  in the instruction file, based on what you saw
- only use the updated instructions for the next round once
  I've approved them

Before the first round, show me the schedule: which item is
in which round and which batch.

Add a section on sources to the instruction file for research
agents. Write it so an agent can't work around it:

- every filled-in field must have a link to the specific page
  the value came from, not just the site's homepage
- a value with no traceable source doesn't get filled in
- if two sources disagree, fill in both and flag the conflict
- mark a company's marketing claims about itself as SOURCE:
  SELF-PUBLISHED, not as fact
- flag values older than [2 years] as OUTDATED
- never present a value you calculated yourself as if it came
  straight from a source

Add one example of a properly sourced row, and one example
of a row that wouldn't pass, with an explanation.

The folder [path] has [200] contracts in PDF. I want to
check each one against the same list of criteria.

Write an instruction file for agents that includes:
1. a list of [12] criteria to check for in every contract:
   [notice period, penalties, automatic renewal, jurisdiction,
   confidentiality, …]
2. for each criterion: what exactly to look for, how to
   record the result (yes / no / not stated), and a
   requirement to cite the clause number in the contract
3. the uncertainty rule — never guess, mark unclear cases as
   NEEDS MANUAL REVIEW
4. an explicit ban on legal judgment: the agent describes what
   the contract says, it doesn't judge whether that's good
   for us
5. output format: one CSV row per contract

Add a warning that the output is background material for a
human, not a legal opinion.

We're migrating [800] records from [old format] to [new
format] following the mapping in [mapping file].

Before we run any batches, write a comparison script,
compare.py, that after the migration verifies:
1. the record count on the input matches the record count on
   the output
2. every input record has a match on the output (by [key
   field]) and vice versa
3. it prints [5] randomly selected records, input and output
   side by side, so I can eyeball them
4. fields that came out blank on the output despite having a
   value on the input — that's the most dangerous case
5. values whose type or format changed

Output as a clear report with numbers. The script doesn't fix
anything. Only run the migration batches after this script
passes on a test sample of 20 records.