Build automation with AI.

1. Step 01

   Claude Pro or Max plan

   An Anthropic account with an active subscription is the baseline. One plan is enough — Pro to start, Max once you need longer sessions or more token budget. Without an active subscription there's no Cowork and no Claude Code.

2. Step 02

   Claude Desktop App (with Cowork)

   Cowork lives as a third tab inside the Claude Desktop App — no extra install needed. There you describe in conversation what you want to build, until the concept is clear.

3. Step 03

   Install Claude Code (terminal + VS Code)

   Two setup paths: terminal (maximum flexibility) or VS Code (code, terminal and Claude in one window) — the output is the same. The command below installs the native client: no Node.js needed, updates run automatically in the background. Security tip: ideally work on a separate computer with no personal data on it. Claude Code gets full file access, so a clean separation matters.

4. Step 04

   Connect MCPs for your automation tools

   It's not just your workflow tool that needs an MCP server — other services you use in automations bring their own MCPs too, like Higgsfield for video generation or ChatGPT/Image for image generation. As of May 2026: n8n has the official n8n MCP, which you enable in n8n under Settings → Instance-level MCP and connect with an access token. Make and Zapier don't have an official MCP — those you build manually in the editor and only use Claude Code for the logic planning. Snippet below is for n8n.

5. Step 05

   Pick hosting (n8n only)

   If you use n8n, pick a cloud where you host yourself. Self-hosted is cheaper than managed cloud and gives you full control over data and workflows. With Make or Zapier you don't get the choice — those run cloud-managed only.

Not sure which path fits? Claude helps you find the right one.

I want to build the following automation: [briefly describe what should happen, how often, which sources/tools are involved].

Quickly check whether this is more of a scheduled task in Cowork, a Claude Code skill, or an n8n workflow, and tell me why. Then build it with me step by step.

What you build with.

Claude Code or n8n?

When is Claude Code enough, and when do you need n8n? Both build automations, but they are made for different jobs. The honest rule of thumb:

Often you need both. Claude Code plans and writes, n8n keeps the long-running jobs alive. In practice though, Claude Code or Cowork alone is enough for most tasks today, n8n only pays off for the genuinely complex cases. Just ask with the generic prompt further up to see what fits your automation.

Turn a workflow into a skill.

An example: a recurring competitor check you would otherwise click together in n8n. In Claude Code it is three steps.

1. Step 01

   Describe the task as a skill

   Create a file at .claude/skills/<name>/SKILL.md in your project. The top says when Claude uses the skill, below it the steps.

   prompt·Prompt to Claude Code

   Copy

   Create a skill at .claude/skills/competitor-check/SKILL.md.
   
   It should:
   1) fetch a competitor's website,
   2) pull out prices and new features,
   3) save the result as a short note in docs/research/.
   
   Write the description so you pick the skill yourself whenever I ask about a competitor.

2. Step 02

   Trigger it on an event

   If a step should run automatically, attach it to a hook in settings.json. Here a lint run after every file edit.

   json·.claude/settings.json

   Copy

   {
     "hooks": {
       "PostToolUse": [
         {
           "matcher": "Edit|Write",
           "hooks": [
             { "type": "command", "command": "npm run lint --silent || true" }
           ]
         }
       ]
     }
   }

3. Step 03

   Schedule it to repeat

   If the workflow should run at fixed times, create a scheduled task. It runs in the cloud, even when your machine is off.

   text·Create a scheduled task

   Copy

   /schedule every Monday 9:00: run the competitor-check skill for our three main competitors and save the notes to docs/research/.

At its core, an automation with Claude Code is just a skill that starts automatically. You can set that up directly via the prompt above — or store the skill in your Agentic OS and start and manage it from there. More on the Agentic OS

Set up my project following Anthropic's guide “Building effective human-agent teams”:

1. WRITE EVERYTHING DOWN: Review my CLAUDE.md and add the context a new agent needs: project goal, architecture, conventions, no-gos.

2. CLEAR ROLES + TOOLS: Create fitting subagents for my project under .claude/agents/ (e.g. reviewer, tester, researcher). Give each one a clear role and only the tools it needs.

3. BIG GOAL: Ask me for the big goal behind this project and write it prominently into the CLAUDE.md. From now on, proactively suggest paths that serve it.

4. VERIFICATION: Create a verifier agent that double-checks finished work and actively tries to find mistakes before I see them. Important tasks only count as done once it has checked them.

Show me at the end what you created and why.

How the generation flow runs after that

Three steps from briefing to a running workflow.

1. 1

   Plan the workflow

   You plan the workflow itself with Cowork. The briefing walks through trigger, data sources, transformations and output in dialogue — you don't have to structure it beforehand. Less is more.

   Copy the prompt below into Cowork, answer the questions. At the end, a markdown file falls out that you hand to Claude Code — and it builds the n8n JSON from it.

   text·workflow-briefing.md

   Copy

   I want to plan an n8n workflow. Please ask me four blocks of questions, one after another:
   
   1) Trigger — what starts the workflow?
   2) Data sources — which tools does n8n have to read?
   3) Transformations — what happens between trigger and output?
   4) Output — what happens at the end?
   
   Per block, always ask only one question at a time and wait for my answer.
   If I get vague, ask for concrete examples.
   
   At the end, create a markdown file "workflow-briefing.md" with:
   - workflow name
   - trigger (type + configuration)
   - data sources (with auth method)
   - transformation logic (step by step)
   - output (with example payload)
   - known edge cases
   

2. 2

   Hand the markdown to Claude Code

   Claude Code reads the briefing and builds the n8n nodes directly in your instance — trigger, AI calls, filters, output. You don't have to drag boxes around any more.

3. 3

   Add credentials

   For each tool in the workflow (Gmail, Notion, Stripe, …) you add an OAuth token or API key in n8n. The workflow only runs live after that.

Why you stop clicking.

With the n8n MCP connected, you don't build workflows by clicking any more. You describe them. Claude Code reads the existing n8n state, plans the JSON, imports it into your instance, and hands you back the workflow link.

Example: Claude Code generates the social-media-reels automation

You hand Claude Code the workflow briefing from the planning phase and say:

Read social-media-reels-workflow.md and build an n8n workflow from it.
The workflow takes a one-pager input (headline, body, image assets, hashtags)
and automatically generates a reel video for Instagram, TikTok, and LinkedIn.

[Alex delivers: detailed workflow steps — trigger, AI calls for script
and voiceover, asset generation via Remotion or video API, posting targets
with auth setup, logging, and error handling.]

Import the workflow directly into our n8n instance via MCP.
Also write a README.md with a trigger payload example and edge cases.

Claude Code reads your briefing, generates the JSON, calls the n8n MCP, imports the workflow, hands you back the n8n editor link. You check visually, click „Activate“. Done.

Cost comparison

Minimal Docker Compose stack

n8n runs as a Docker container next to Postgres and Caddy. Caddy handles HTTPS automatically via Let's Encrypt — you don't have to configure any certificates.

services:
  postgres:
    image: postgres:16
    restart: unless-stopped
    environment:
      POSTGRES_USER: n8n
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: n8n
    volumes:
      - postgres_data:/var/lib/postgresql/data

  n8n:
    image: n8nio/n8n:latest
    restart: unless-stopped
    environment:
      DB_TYPE: postgresdb
      DB_POSTGRESDB_HOST: postgres
      DB_POSTGRESDB_DATABASE: n8n
      DB_POSTGRESDB_USER: n8n
      DB_POSTGRESDB_PASSWORD: ${POSTGRES_PASSWORD}
      N8N_HOST: ${N8N_HOST}
      N8N_PROTOCOL: https
      WEBHOOK_URL: https://${N8N_HOST}/
      GENERIC_TIMEZONE: Europe/Berlin
    depends_on:
      - postgres
    volumes:
      - n8n_data:/home/node/.n8n

  caddy:
    image: caddy:2-alpine
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - caddy_data:/data
      - caddy_config:/config

volumes:
  postgres_data:
  n8n_data:
  caddy_data:
  caddy_config:

Let Claude Code roll out the setup on the server. Add SSH key, clone the repo, [docker compose up -d]. A backup cron is part of it — Claude writes the script along with it.

If you don't know how all of this works, just ask Claude Code: it knows the stack, walks you through step by step and corrects you when you mistype. You don't have to remember any of it — you only have to describe what should run at the end.

The four building blocks.

Build the second brain.

The first building block, step by step. An Obsidian vault as your knowledge store, with Claude writing along.

1. Step 01

   Install Obsidian

   Obsidian is a free note app that stores your notes as plain markdown files in a folder. That folder becomes your vault.

   Download Obsidian
2. Step 02

   Create the vault and start Claude

   Create an empty folder and open it in Obsidian via “Open folder as vault”, not via “Create new vault”. Then start Claude Code in the same folder.

   bash·Terminal

   Copy

   mkdir ~/second-brain
   cd ~/second-brain
   claude

3. Step 03

   Set up structure and rules

   In the first prompt you build the skeleton: a CLAUDE.md that makes Claude the keeper of the vault, plus the folder structure.

   prompt·Prompt 1

   Copy

   We are turning this folder into a second brain.
   
   Create a CLAUDE.md that describes you as the keeper of this vault. Structure: raw/ for raw notes, wiki/ for linked articles, index.md as the entry point, log.md for changes.
   
   Define three operations: Capture (file a new note), Look up (answer a question from your knowledge), Tidy up (keep structure and links clean). Keep the CLAUDE.md under 200 lines.

4. Step 04

   Build up and link the knowledge

   Now you expand the vault. One subagent per topic, plus cross-links between related notes.

   prompt·Prompt 2

   Copy

   Expand the vault. Take the topics in raw/, research each one with a subagent, write an article per topic into wiki/ and add [[wikilinks]] between related notes. At the end, update index.md and log.md.

5. Step 05

   Point auto memory at the vault

   Auto memory is on by default from Claude Code 2.1.59: Claude remembers what matters on its own. Otherwise those notes land under ~/.claude/projects/. One line in settings.json puts them in your vault, so you read them in Obsidian too.

   json·.claude/settings.json

   Copy

   {
     "autoMemoryDirectory": "~/second-brain/claude-memory"
   }

6. Step 06

   Sync across multiple computers

   To keep your brain identical on every computer and in the cloud, put the vault folder in a private Git repo. Clone it once on every other machine. Pull the latest state before you work, push it back when you are done. Because the auto memory sits inside the vault, it travels too. If you want it without a terminal, use Obsidian Sync (paid, no setup).

   bash·Terminal (one-time setup)

   Copy

   cd ~/second-brain
   git init && git add . && git commit -m "second brain"
   # create a private repo on GitHub, then connect it:
   git remote add origin git@github.com:YOUR-NAME/second-brain.git
   git push -u origin main
   # other machine: git clone ... ; then git pull (start) / git push (end)

The next stages: your own agents.

Once the second brain stands, you build agents on top. Three stages we run ourselves:

The cockpit.

Live

Our own agentic OS.

An agentic OS is the command center for your AI agents: one place for skills, automation status and direct access, instead of scattered terminals and dashboards.

Our own agentic OS is live: a cockpit plugin for Obsidian with an embedded terminal, a skills overview, and automation status. Free to download - the full story and setup steps are in the repository.

Download the cockpit pluginRead the full story