Build automation with AI.

1. Step 01

   Install the Claude desktop app (for Cowork)

   Cowork lives in the Claude desktop app. You use it to plan your automation in dialogue — or you build small automations directly via scheduled tasks that run at fixed times. We show how just below.

   Get the Claude desktop appTo Cowork + scheduled tasks
2. Step 02

   Install Claude Code

   Claude Code is the anchor of the whole setup — you build and import your workflows with it. If you've done the „Build products with AI“ cluster, this is nothing new. Install via the terminal, in VS Code, or alongside in the desktop app.

   bash·Install via terminal

   Kopieren

   npm install -g @anthropic-ai/claude-code

   Claude Code download and docs
3. Step 03

   Pick an automation tool — n8n, Make or Zapier

   Three sensible options. n8n (open source, official MCP server, self-hostable) — our pick if you want to generate workflows with Claude Code. Make.com (SaaS, visual editor, huge integration library) — good if you think visually and don't want self-hosting. Zapier (8,000+ integrations, friendliest onboarding) — good if you just want to connect a few apps without digging in deeper. For DACH/EU all three offer EU regions. For AI-driven workflow generation, n8n stays ahead.

   n8n.io
4. Step 04

   Connect an MCP for your tool

   With an MCP server, Claude Code reads and writes directly in your workflow instance — generates workflow JSON, imports it, tests trigger payloads. As of May 2026: n8n has the official n8n MCP. 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.

   bash·n8n MCP connected to Claude Code (if you picked n8n)

   Kopieren

   claude mcp add n8n --transport http \
     "https://YOUR-N8N-DOMAIN/mcp" \
     --header "Authorization: Bearer YOUR_N8N_API_KEY"

   n8n MCP repo on GitHub
5. Step 05

   Pick hosting

   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.

   Our pick: Hetzner Cloud, from €5/month

   CX22 (2 vCPU, 4 GB RAM), EU region Falkenstein or Nuremberg. n8n + Postgres + Caddy as a Docker Compose stack, Claude Code rolls it out initially. Same thing works on DigitalOcean, AWS Lightsail or Scaleway — Hetzner wins on price-performance.

   Hetzner CloudHetzner setup in detail

What you build with.

Claude Code or 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.

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

   Kopieren

   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

   Kopieren

   {
     "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

   Kopieren

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

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.

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

   Kopieren

   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

   Kopieren

   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

   Kopieren

   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

   Kopieren

   {
     "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)

   Kopieren

   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.