Claude Code builds your n8n workflow: the checklist · Resource

Keep this card open next to your Claude Code conversation whenever you ask it to build an n8n workflow. The blocks follow the real order of work: you set up the project once, then for every workflow you go through the brief, the plan, the build, the review, and the test. Each block has boxes to tick and one sentence to remember.

The rule above all others: the agent builds, you sign off. No box on this card passes to the agent just because validation succeeded.

Project and CLAUDE.md (once per project)

The project is the folder where the agent works and saves files. CLAUDE.md is the standing instruction for that folder: what it's for, what environment the agent works in, which rules it follows.

[ ] Create a separate, empty folder just for building n8n workflows and open it in an editor with Claude Code.
[ ] Switch the agent to plan mode before you ask for anything.
[ ] Ask the agent to draft CLAUDE.md: the project exists to build workflows in your n8n instance using the n8n MCP server and skills.
[ ] Answer its questions: which tools it will use, and whether n8n runs in the cloud or on your own server.
[ ] Paste in the addresses of the MCP server and skills repositories so the agent reads them itself.
[ ] Read the finished file and check that it describes the order of work: requirements, templates, nodes, build, validation, deployment.
[ ] Check that the file includes safety rules; if they're missing, add at least this one: nothing gets activated without my approval.

A project without CLAUDE.md starts every conversation from zero. A project with one starts from your rules.

MCP server, skills, and API key (once per project)

The MCP server is the agent's hands: the node catalogue, the templates, and access to your instance. The skills are knowledge it reads on demand: expressions, node configuration, patterns, validation, code. The API key is the password the agent uses to log in to your n8n.

[ ] Hand the install to the agent: install this server and these skills, and make sure they work in this project.
[ ] When the agent asks for the instance address, give it your n8n address without the rest of the path.
[ ] Create a dedicated API key for this project in your n8n settings, and name it so you know what it's for.
[ ] If your n8n plan lets you restrict the key's permissions, grant only what the project needs.
[ ] Find out which project file the key ended up in, and make sure that file never reaches a repository or a shared folder.
[ ] Restart Claude Code so it loads the server and the skills.
[ ] Test the connection: ask it to search for the webhook node through the MCP server.
[ ] Ask directly whether the agent can create workflows in your instance and whether the n8n skills are loaded; expect specifics, not reassurance.
[ ] Note when you created the key and delete it when the project ends.

An n8n API key opens the whole instance. Treat it as a password, not a setting.

The brief and a sketch (for every workflow)

The agent can't guess what you didn't write. The brief is your only specification, so write it the way you'd explain the job to a developer.

[ ] State what triggers the workflow: a time of day, a form, a new email, a manual click.
[ ] Describe what should happen, step by step, in plain sentences.
[ ] State where the result should go and in what form: email, spreadsheet, a chat message.
[ ] If you want several AI agents, describe each one separately: role, input, output, and the model it should use.
[ ] Give the time zone for every time in the schedule.
[ ] Sketch the flow, even by hand: what starts it, where it branches, where the data goes. Attach a screenshot to the brief.
[ ] Say explicitly that the workflow should be created in your n8n instance, not as a file on disk.
[ ] Judge the size: if the flow runs to several dozen nodes, split it into parts and describe only the first.

A good brief is one another person could build the same workflow from without asking a single question.

The plan before the build

In plan mode the agent only analyses and proposes. It's the cheapest moment to catch a misunderstanding.

[ ] Send the brief in plan mode, not in execution mode.
[ ] Answer every clarifying question; if you don't know the answer, ask the agent to explain the options.
[ ] Read the whole plan: the architecture, the list of nodes, the configuration of each.
[ ] Check where the workflow will be created: in the instance or as a file.
[ ] Check that the plan uses the tools and models you specified.
[ ] If something is unclear, ask why it chose that approach.
[ ] Correct the plan with one sentence before execution rather than reworking a finished workflow.
[ ] Turn on automatic execution only once you trust the plan.

Fixing the plan costs one sentence. Fixing a finished workflow costs a full review.

Build and validation

The agent creates the workflow, validates it, and fixes configuration errors itself. Your role here is to watch, not to click.

[ ] Follow the agent's task list: create, validate, report.
[ ] When the agent stops to ask for missing information, answer it instead of telling it to guess.
[ ] Note which errors the agent fixed on its own; those are the first places to look during review.
[ ] Collect the link to the workflow and the list of next steps.
[ ] Don't activate the workflow just because validation passed. Validation checks that the configuration is valid, not that it matches what you ordered.

Validation tells you the workflow can run. It doesn't tell you it does what you asked.

Review every node before switch-on

This is the block you never shorten. The agent can set a different model from the one you specified and add parameters nobody asked for.

[ ] Connect the credentials yourself in every node that needs them: search tool, model provider, email.
[ ] In every AI agent node, check the model and its version against your brief.
[ ] Check parameters the agent added on its own, such as a response length limit or temperature, and remove the ones you don't want.
[ ] Read each agent's system prompt in full: role, scope, output format.
[ ] Read each agent's input message and check that the expressions point at the right fields from the previous step.
[ ] Check the output node: recipient address, subject line, content format.
[ ] List the decisions the agent made for you, such as a switched-off attribution line or an added option, and decide which ones stay.
[ ] Check the schedule: time of day and time zone.

Any node that hasn't been through your hands is an assumption, not a configuration.

Test run

[ ] Run the workflow manually before you switch the schedule on.
[ ] Trace the output of every step: what the first agent found, what the second received, what came out at the end.
[ ] Check the result where it will really land: the inbox, the spreadsheet, the chat channel.
[ ] Check that the result includes the sources or data you asked for.
[ ] Switch the schedule on only after a clean run.

You do the first run yourself, watching. The schedule only gets what you've already seen work once.

Safe limits

[ ] Build in pieces: one part of the flow, review, test, then the next part.
[ ] Don't order a workflow of several dozen nodes in one request; an oversized request can overload the instance until it stops responding.
[ ] If the agent starts retrying the same thing after timeouts, stop it and split the task.
[ ] On a cloud instance, remember you can't restart it yourself; on your own server, know how to restart it.
[ ] When the agent suggests you install or configure something yourself and there's no reason to do it by hand, ask it to do it.

A smaller request finishes sooner and breaks less.

Changes and further iterations

[ ] Request changes in the same conversation: a prompt, a tool, a new section.
[ ] After every change, check in n8n exactly what changed.
[ ] After every significant change, repeat the node review and the test run.
[ ] When you don't understand what the agent did, ask it to explain.
[ ] When the same correction keeps coming back across workflows, add it to CLAUDE.md as a rule.

The agent builds, you sign off. That order holds for every iteration.