Automate content with Claude MCP

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 complete assistant specification (intents, responses, system prompt, guardrails, tests).

There is a standing automation that normally produces this. It is called Claude MCP Content Automation, and the video that demonstrates it is titled "Automate Anything With Claude MCP Workflows, Here's how:". Here is what that pipeline actually does:

Ben AI demonstrates a robust automation system that integrates Claude MCP workflows with n8n for content repurposing. The system uses cloud triggers to orchestrate a series of tools: YouTube transcription, fine-tuned LinkedIn post generation, dynamic image creation via external APIs, and Air Table/Webflow updates. The workflow is designed for social media and blog content automation with human-in-loop iterations, offering a detailed, step-by-step solution. Free template available.

The original pipeline is built in n8n and wires together: Claude, MCP, n8n, Webflow, YouTube, LinkedIn.

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.

Scope what the assistant is allowed to do.

1. List the intents this assistant handles, in priority order, with an example utterance for each.
2. For each intent, state whether it is fully handled, partially handled, or handed off - and why.
3. Define the out of scope list explicitly: what it must never attempt.
4. Define the handoff triggers: the specific signals that mean a human takes over. Be concrete - "the user is angry" is not a trigger, "the second message expresses dissatisfaction and the issue is billing" is.
5. Tell me what it needs to know at the start - account data, product data, policy - and the format for that.

Output an intent map with scope boundaries. This is the contract the rest of the build follows.

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.

Write the actual answers.

1. For the top intents, write the gold-standard response for each: the reply the assistant should give when everything goes right.
2. For each of the top five intents, write the edge-case responses - wrong assumption, missing information, partial answer, second attempt.
3. Write the response for each handoff trigger - warm, brief, and honest that a human is taking over. Never make it sound like the assistant has disappeared.
4. Define the tone rules: what the voice always does, and what it never does. Give two one-line examples of each.
5. Write the response when the assistant genuinely does not know, and it must not bluff.

Output as a response library, keyed by intent. Each entry: the trigger, the response, and the escalation flag.

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 system prompt that governs all of it.

1. Write the complete system prompt as one copy-pasteable block. Include role, the intent map, the scope boundaries, the handoff triggers, the tone rules, and the escalation behaviour.
2. Write it so it degrades safely: if the user goes off-topic, what happens? If the user pushes past a boundary, what happens?
3. Add the refusal and boundary language, phrased so it does not sound like a policy notice dropped into a conversation.
4. Add the memory rules: what gets remembered between turns and what must not.
5. Now write the same prompt in a tighter version - half the length, same behaviour. Give both, and say which to use when.

Output both blocks labelled clearly. The tight version must genuinely be tighter, not just shortened.

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 5; do not restart or re-brief yourself.

Prove it works.

1. Write 15 test cases spanning the intent map, including at least three that should trigger handoff and three that should be refused.
2. For each: the user says, what the assistant should do, and the pass condition.
3. Write three multi-turn conversations that go wrong in realistic ways - the user changes their mind, gives wrong information, or loses patience - and what the assistant should do at each turn.
4. Write the five questions a sceptical operator would ask about this setup, with honest answers.
5. Give me the failure list: the cases where you expect this to behave badly, and what to change if it does.

Output the test set so I can actually run it against the assistant.

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 complete assistant specification (intents, responses, system prompt, guardrails, tests).

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.