Handle email complaints

We are working in ONE conversation. Every turn from here builds on the last. Do not restart, do not ask me to re-paste anything, and do not ask me to confirm the brief - it is below.

The brief

I want a prioritised inbox action queue with drafted replies.

There is a standing automation that normally produces this. It is called Email & Complaint Automation, and the video that demonstrates it is titled "Don’t Build Another AI Agent Until You Understand This: AI Agents vs AI Workflows ~ n8n". Here is what that pipeline actually does:

In this video, Mahmut Kasimoglu demonstrates two specific n8n systems built for automation: an email labeling system and a complaint ticket processing system. Both systems show a direct comparison between an AI agent approach and an AI workflow approach. The email system uses a Gmail trigger, LLM-based classification, tool calls to get label IDs, label emails, and send notifications, while the complaint system integrates Google Sheets and email notifications. A free template for these workflows is available via his Skool community.

The original pipeline is built in n8n and wires together: Google Sheets, Gmail, n8n.

What is different about this session

That automation is a permanent pipe. I do not want the pipe. I want the output, once, produced by you working through this conversation with me over the next few turns. Do not produce an n8n JSON export, a node graph, or a workflow diagram. Produce the thing the pipe was built to produce.

Your job right now

1. Read the brief and restate the deliverable in one sentence, in your own words, so we agree on what "done" means.
2. Write a numbered execution plan - the actual production steps, in order, that you will carry out across this conversation. Be concrete: each step names an artefact it will produce.
3. List the inputs I must give you for the plan to be executable. For each one, show the exact shape you want it in, with a fill-in-the-blank template I can type over. Assume I have none of this ready.
4. Flag anything in the brief that is ambiguous or that you will have to assume. Make an explicit, defensible assumption rather than asking a vague question.
5. State the final output format you will produce in the last turn (file layout, sections, length).

Constraints for everything you produce in this conversation:
• Concrete and finished. No placeholders left where a real value belongs, no "insert your X here".
• If you cannot verify a fact, say so inline rather than inventing it.
• Every claim that rests on an external fact gets a source.
• Optimise for something I can act on this week, not for a textbook answer.

Before you continue: The assistant should restate the deliverable and give you a numbered plan plus the inputs it needs. Answer its questions before continuing.

Continue from Turn 1. Do not re-plan from scratch.

Take the numbered plan you produced and turn it into a locked execution checklist:

1. Restate it as a checklist where every line is a specific artefact with a one-line definition of "finished". For example: #3 - Hook table: 10 hooks, each <= 8 words, each paired with the segment it comes from.
2. Tell me, in priority order, which inputs I must supply right now to unblock the most work. Give me a single copy-paste block with the fill-in-the-blank fields already laid out. If an input genuinely cannot be typed (a file, a link list, an API response), tell me exactly what to paste and what shape it should be.
3. Where you made an assumption in Turn 1, state it again in one line and tell me what it would cost if it is wrong. Mark each assumption as HIGH or LOW impact.
4. Tell me the order you will work in and exactly which turn each checklist item lands in, so I know what I am waiting for at each step.

Then stop and wait for my input. Do not start producing deliverables yet - I need to see the checklist first.

Before you continue: The assistant produces this stage. Read it, answer anything it asks, then paste the next turn in the same chat.

Continue in this same conversation. Everything below builds on Turns 1 to 2; do not restart or re-brief yourself.

Define how we handle the mailbox before we touch it.

1. Classify the account's mail into buckets, and for each bucket state: what lands there, the response time expected, and who it is for. Typical buckets: urgent human reply, scheduled reply, FYI, finance, calendar, newsletter and marketing, notification noise.
2. Write the decision rules in plain language - the test a person would apply to decide which bucket. Ambiguity here is what causes the wrong email to get a wrong reply.
3. Define the do-not-touch list: anything legal, financial, medical, or personal that must never be auto-replied to and must always be escalated.
4. Define my voice: how I write, how formal, typical sign-off, what I never say.
5. Tell me what you need pasted to work with - the inbox export format, and how much of it.

Output a one-page rules doc. This governs everything after it.

Before you continue: The assistant produces this stage. Read it, answer anything it asks, then paste the next turn in the same chat.

Continue in this same conversation. Everything below builds on Turns 1 to 3; do not restart or re-brief yourself.

Read the actual mail and rank it.

1. Go through the inbox and assign every item to a bucket from the rules.
2. Produce a priority queue, ordered by: who is waiting, how long they have been waiting, and what is blocked behind it.
3. For each item in the top of the queue, state in one line what the sender actually wants and what the reply is.
4. Flag anything that looks time-critical or has an emotional charge - these get handled first regardless of apparent importance.
5. List anything you are unsure about, with your uncertainty stated, rather than guessing the bucket.

Output the ranked queue as a table: sender | bucket | wants | reply needed | urgency. Do not draft replies yet.

Before you continue: The assistant produces this stage. Read it, answer anything it asks, then paste the next turn in the same chat.

Continue in this same conversation. Everything below builds on Turns 1 to 4; do not restart or re-brief yourself.

Write the replies.

1. Draft a reply for everything in the top of the priority queue. Match my voice from the rules doc - not a generic assistant tone.
2. Where I do not have the information needed to answer, draft the reply with the gap marked clearly, and tell me what I need to look up. Never invent facts in an email to a real person.
3. Draft the FYI-summary items as a single digest rather than separate replies, where a digest makes sense.
4. For anything ambiguous or adversarial, do not draft a reply - tell me why you are escalating it instead.
5. Show each draft with a one-line note on what it commits me to, so I can check the promise before sending.

Output: draft, then the commitment note. No drafts for the do-not-touch list.

Before you continue: The assistant produces this stage. Read it, answer anything it asks, then paste the next turn in the same chat.

Everything is produced. This turn is about making it one coherent thing rather than a pile of parts.

1. List every artefact produced so far in this conversation, by the name we agreed in the checklist. Flag anything from the checklist that is missing or thin.
2. Cross-check the parts against each other and report the inconsistencies you find. Be specific: which artefact says one thing and which says another. Fix them, and show the fix.
3. Rewrite the pieces that depend on each other so they use one consistent vocabulary, one consistent naming scheme, and one consistent tone. Show the corrected versions of anything you changed.
4. Identify the three weakest parts of the work and tell me honestly what would improve them. If you think something should be cut rather than polished, say so.
5. Produce a short READ ME FIRST section for the final deliverable: what this is, who it is for, how to use it, and what to do first.

Keep the README under 300 words.

Before you continue: The assistant produces this stage. Read it, answer anything it asks, then paste the next turn in the same chat.

Now assemble the finished a prioritised inbox action queue with drafted replies.

1. Produce the complete deliverable in the format you committed to in Turn 1. Use every artefact from this conversation - do not start over, and do not leave anything as a note to self. This is the version I keep.
2. Run a self-check before you send it, and show the check as a short table at the end:
   • Is every checklist item from Turn 2 actually covered? List any that are not.
   • Does anything still contain a placeholder, a TODO, or an unverified claim?
   • Is the thing internally consistent - numbers, names, dates, cross-references?
   • If a real person acted on this on Monday morning, what would they trip over? Fix it.
3. Give me a NEXT 3 ACTIONS list: the three concrete things to do next, each with an owner and a timeframe. Not a wishlist - three things I can start.
4. If any part of this deliverable should be regenerated weekly or monthly, say which part and give me the single prompt that would do it, so I can reuse it.

Output the deliverable first, then the self-check table, then NEXT 3 ACTIONS.

Before you continue: The assistant produces this stage. Read it, answer anything it asks, then paste the next turn in the same chat.