Two AIs, One Project

Help me set up a simple routine for using two AI tools on one project. I'm a beginner, so keep it plain.

The AI tools I have: [THE AI TOOLS I HAVE]
What I'm building: [WHAT I'M BUILDING]
Where I get stuck most: [WHERE I GET STUCK MOST]

Please:
1. Ask me up to 3 short questions if anything above is unclear. Wait for my answers before going on.
2. Give each tool one main job: planner (thinks through what to build and checks results) or builder (edits the code). Only one tool should edit my code. Explain your choice in one or two sentences, based on what each tool can actually do in my setup. For example, a normal chat can't see my project files unless I paste or upload them.
3. Write my routine as 5 to 7 short steps, from "I have an idea" to "the change is done and checked."
4. Tell me exactly what I should pass from one tool to the other at each step, and what I should NOT paste (like whole conversations, secrets, or my .env file).
5. List 3 signs that I should stop and switch tools, and 3 signs I'm switching too much.
Keep the whole answer short enough to fit on one page.

I use two AI tools on this project, and I want a shared handoff file so either one can catch up quickly. Don't change any app code.

My tools: [MY TOOLS]
My rules file: [MY RULES FILE]
What I'm working on now: [WHAT I'M WORKING ON NOW]

Please:
1. Look around the project so you understand it, then create HANDOFF.md in the project root with these short sections:
   - Goal: what we're building right now, in one or two sentences
   - Current state: what works, what's half-done, what's broken
   - Files touched recently: with one line on each
   - Decisions made: and why, one line each
   - Next step: the single next thing to do
   - Open questions: anything waiting on me
   - Don't touch: files or areas to leave alone
2. Fill it in from what you can see in the code and recent git history. Mark anything you're guessing with "(guess)".
3. Keep it under 60 lines. Plain words, no long explanations.
4. Suggest one short line to add to my rules file that asks the AI to read HANDOFF.md at the start of a session and update it at the end. If I don't have a rules file, tell me which one my tools read.
5. Show me the file and the suggested line before saving anything.

Help me plan a feature that a different AI tool will build. You're the planner. You can't see my code, so ask me for anything you need instead of guessing.

The feature: [THE FEATURE]
My app and stack: [MY APP AND STACK]
What already works: [WHAT ALREADY WORKS]
My builder tool: [MY BUILDER TOOL]
Handoff notes: [HANDOFF NOTES]

Please:
1. Ask me up to 5 questions first if anything important is missing. Wait for my answers.
2. Write the plan as 3 to 7 numbered steps. Each step should be small enough to build and check in one sitting.
3. For each step, include: what to build, which parts of the app it probably touches (mark these as guesses, since you can't see my files), and "Done when:" a check I can do myself, like "I click Save and the reminder time still shows after a refresh."
4. Add a short "Don't" list for the builder, like "don't change login" or "don't add new packages without asking."
5. Add "Questions for the builder": things it should check in the real code before starting.
6. Put the whole plan in one code block so I can copy it in one go.
Keep the plan simple. Don't add features I didn't ask for.

Another AI wrote the plan below. You're the builder. Work on step [STEP NUMBER] only.

The plan:
[THE PLAN]

Please:
1. Before writing any code, read the files this step touches. Answer the plan's "Questions for the builder." Tell me if anything in the plan doesn't match the real code. If something's wrong, stop and tell me instead of working around it.
2. Tell me in 3 to 5 lines what you're going to change. Wait for my OK.
3. Build step [STEP NUMBER] only. Follow the plan's "Don't" list. Don't start the next step.
4. Check your work against that step's "Done when" line. Run any tests, the build, or the linter this project uses. Tell me exactly how I can check it myself.
5. Write a short report for the planner in one code block, under 150 words:
   - Step: the number and name
   - What changed: one line per file
   - How it was checked: and the result
   - Surprises: anything that didn't match the plan
   - Questions: anything the planner needs to decide
If you also update HANDOFF.md, show me the change first.

You're the planner. The builder finished a step and sent the report below. Check it before I move on.

The plan:
[THE PLAN]

The builder's report:
[THE REPORT]

What I saw when I tried it:
[WHAT I SAW WHEN I TRIED IT]

Please:
1. Compare the report and what I saw with the step's "Done when" check. Say plainly: done, not done, or not sure.
2. List anything the builder changed that wasn't in the step, and anything in the step it skipped.
3. Answer the builder's questions, or tell me which ones I need to decide myself.
4. If the builder found surprises, update the remaining steps to fit. Show only the steps that changed.
5. Write my next message to the builder in one code block: either "fix this first" with the exact problem, or "go ahead with the next step," naming which step.
Only use what's in the report and what I saw. Don't assume the code does anything the report doesn't say.

Another AI wrote the change below. Review it, but don't rewrite it. I only want bugs and risks.

What the change is supposed to do: [WHAT THE CHANGE IS SUPPOSED TO DO]
Anything I'm worried about: [ANYTHING I'M WORRIED ABOUT]

The diff:
[THE DIFF]

Please:
1. Tell me in one or two sentences whether the change looks like it does what it's supposed to.
2. List real problems only: bugs, security risks (like exposed secrets or missing permission checks), data that could be lost, and cases that would break (empty input, logged-out users, slow connections). For each one, quote the line, explain the problem in plain words, and rate it high, medium, or low.
3. Separately, list anything you can't judge without seeing more code, and which file you'd need to see.
4. Don't suggest style changes, renames, or rewrites unless they fix a real problem.
5. If you find nothing serious, say so. Don't invent problems to have something to say.
End with a short list of fixes I can paste back to the AI that wrote it.

Two AI tools gave me different fixes for the same problem. Help me figure out which one is right, using the evidence. Don't just pick the one that sounds better.

The problem: [THE PROBLEM]
The exact error: [THE EXACT ERROR]
Fix from the first AI: [FIX FROM THE FIRST AI]
Fix from the second AI: [FIX FROM THE SECOND AI]
What I've already tried: [WHAT I'VE ALREADY TRIED]

Please:
1. For each fix, explain in plain words what it assumes is causing the problem.
2. Check each assumption against the exact error. Which one does the error actually support? Quote the part of the error you're relying on.
3. Suggest one small check I can do in a few minutes that would show which assumption is true, like adding a log line, checking one setting, or trying one input. Tell me what result would point to each fix.
4. Tell me which fix to try first and why. If both might be wrong, say so, and tell me what to look at instead.
5. Tell me what to undo if the first fix doesn't work, so I'm not stacking fixes on top of each other.
Don't write a third fix unless the evidence rules out both.

I'm finishing this session. Update [HANDOFF FILE] so the next AI, or me tomorrow, can pick up without asking anything. Don't change any app code.

What I worked on today: [WHAT I WORKED ON TODAY]

Please:
1. Check what actually changed using git status, the recent commits, and the files we edited. Trust what you see in the project over what we said in chat.
2. Update every section of [HANDOFF FILE]: Goal, Current state, Files touched recently, Decisions made, Next step, Open questions, Don't touch.
3. Replace old information instead of adding to the bottom. Remove anything that's no longer true. Keep it under 60 lines.
4. Be honest about anything half-done or untested. Write "not tested" where it applies.
5. Make "Next step" one specific action, not a vague goal.
6. Show me the changes before saving.
7. Then write a summary of the handoff in one code block, under 120 words, that I can paste into my other AI.

We're starting a new session. Before doing anything, catch up on where this project stands.

Handoff notes: [HANDOFF FILE]
What I want to do today: [WHAT I WANT TO DO TODAY]

Please:
1. Read the handoff notes.
2. If you can see my project, check them against reality: run git status and look at the last 10 commits. Tell me anything that changed since the notes were written, or anything the notes say that doesn't match the code. If you can't see my project, skip this and list what you'd want me to check.
3. Repeat the current state and the next step back to me in your own words, in 5 lines or fewer.
4. Tell me whether what I want to do today fits the next step, or whether something else should come first.
5. List any open questions from the notes that I need to answer before we start.
Wait for my OK before making any changes.