Replace Make.com and n8n with Claude Code Routines

Make.com and n8n have dominated workflow automation for years, but Claude Code routines offer a developer-first alternative that sidesteps their pain points. Here’s a full comparison, migration tutorial, and cost analysis to help you decide.

Table of Contents

Why Workflow Automation Is Ripe for Disruption

Make.com and n8n have dominated workflow automation for years. Developers use them to wire APIs together, transform data, and run scheduled tasks without writing glue code. But living inside these platforms grates over time. Pricing tiers escalate sharply with usage. Visual interfaces obscure the actual complexity underneath. Debugging means clicking through layered GUI logs. And vendor lock-in makes migration painful. Make.com’s operations-based billing can spike unpredictably. n8n’s self-hosted option helps with cost but shifts operational burden. Both constrain developers to their abstractions.

Claude Code routines offer a developer-first alternative that sidesteps these pain points. You define reusable, multi-step automated workflows in plain Markdown, then run them through the Claude Code CLI. This approach replicates the workflow types covered in this article (data pipelines, API enrichment, and conditional notification routing) at a fraction of the cost, with native AI reasoning built in, full version control through Git, and reduced proprietary lock-in. Routine files are portable Markdown, though execution behavior depends on Claude’s specific tool use implementation.

What Are Claude Code Routines?

Important: The routines subcommand and workflow described in this article reflect proposed Claude Code functionality. Verify current CLI capabilities in the official Claude Code documentation before implementing. Feature availability may differ from what is described here.

Routines Explained in 60 Seconds

A Claude Code routine is a Markdown-defined, reusable set of multi-step instructions that Claude Code runs sequentially or conditionally. You store routines as .md files in your project; they tell Claude what to do step by step, including which tools to use, what conditions to evaluate, and what outputs to produce. Routines differ from one-off prompts in concrete ways: they maintain context across steps within a single session (subject to the model’s context window limits), use Claude’s built-in tool capabilities, access the file system directly, and follow structured paths rather than generating a single response.

Why Routines Are More Than Fancy Prompts

The distinction matters because routines have access to real tool use. Claude Code can run shell commands, perform file I/O, make API calls via curl or any CLI tool, and process the results within the same context. Routines support looping, branching, and error handling through natural language instructions that Claude interprets. A routine might say “if the API returns a 429 status, wait 30 seconds and retry up to 3 times,” and Claude Code follows those instructions directly. For production-critical workflows, supplement natural language retry logic with explicit shell-level error handling to ensure deterministic behavior.

Routine files are plain Markdown. They live in the repository alongside application code, are diffable, reviewable in pull requests, and tracked in Git history. No proprietary JSON exports, no platform-specific serialization formats.

Feature-by-Feature Breakdown

¹ Based on ~5,000 runs/month of moderate-complexity routines averaging ~1,500 input + ~800 output tokens per run at Claude Sonnet-class pricing. Verify current per-token rates at anthropic.com/pricing.

Note: Data submitted to routines is processed by Anthropic’s API. Review Anthropic’s data usage policy before processing sensitive data.

When Claude Code Routines Win (and When They Don’t)

Claude Code routines fit best in specific conditions:

• Developer-centric teams comfortable in the terminal. If your team already lives in VS Code and iTerm, routines slot into existing habits.
• Workflows with 3+ branching conditions or loops over variable-length datasets, where visual canvas tools become cluttered.
• Automations that benefit from AI reasoning at each step, such as classification, summarization, or anomaly detection baked into the workflow itself.
• Cost-sensitive projects where operations-based billing becomes expensive at scale.

Non-technical teams who need drag-and-drop interfaces should not use routines. The same goes for workflows that depend heavily on 500+ pre-built connectors with zero-configuration OAuth setup, or real-time webhook-triggered pipelines requiring sub-second response times. Claude Code routines carry the latency of LLM inference (typically 2 to 15 seconds per step depending on complexity, versus sub-second for webhook triggers), which makes them unsuitable for synchronous, latency-critical paths.

Setting Up Your First Claude Code Routine

Prerequisites

You need three things before building a routine: the Claude Code CLI installed and authenticated, an Anthropic API key with sufficient credits, and basic familiarity with terminal usage and Markdown syntax.

Requires Node.js 18 or later. Run node --version to verify. Install or update Node.js at nodejs.org.

You will also need curl and jq installed in your execution environment. On Ubuntu/Debian: sudo apt-get install -y curl jq. On macOS with Homebrew: brew install curl jq.

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




export ANTHROPIC_API_KEY="your-key-here"


[[ -n "$ANTHROPIC_API_KEY" ]] && echo "ANTHROPIC_API_KEY is set" || echo "WARNING: ANTHROPIC_API_KEY is not set"


claude --version

Note: Alternatively, run claude auth login if your installation supports OAuth-based authentication. Consult the official Claude Code setup documentation for your version.

Anatomy of a Routine File

Routines follow a directory convention: they live in .claude/routines/ within a project repository (verify the current path convention in the official Claude Code documentation, as it may vary by version). Each routine is a single Markdown file with a clear structure consisting of a title, a description of the objective, step-by-step instructions, and any tool permissions or constraints.

# Routine: Data Pipeline Template

## Objective
Process incoming data, validate it against business rules, and deliver results to the configured output destination.

## Prerequisites
- Required environment variables: `API_KEY`, `OUTPUT_WEBHOOK`
- Input file expected at: `./data/input.csv`

## Steps

### Step 1 — Load and Validate Input
Read the file at `./data/input.csv`. Verify it contains the required columns: `name`, `email`, `value`. Report any rows with missing fields and exclude them from further processing.

### Step 2 — Transform Data
For each valid row, normalize the email to lowercase and round `value` to two decimal places.

### Step 3 — Deliver Results
Write the transformed data to `./data/output.json` in a JSON array format. Log the count of processed rows to the terminal.

## Error Handling
If any step fails, log the error with context and continue processing remaining rows. Do not halt the entire routine on a single row failure.

## Permissions
- File system: read/write within `./data/`
- Shell commands: `curl`, `jq`

The Scenario Being Replaced

Consider a common Make.com scenario: “When a new row appears in Google Sheets, enrich the data via an external API, apply conditional logic, and post a formatted summary to Slack.” In Make.com, this workflow consists of 5 to 6 connected modules: a Google Sheets trigger, an HTTP module for the enrichment API call, a filter or router for conditional logic, a text aggregator for formatting, and a Slack module for posting the message. Each module consumes operations, and the visual canvas grows cluttered as edge cases multiply.

Note: This tutorial uses a CSV export from Google Sheets as the input. The original Make.com scenario’s real-time trigger is not replicated here; you would need to schedule the export or use the Google Sheets API separately.

Step 1: Define the Routine in Markdown

The following routine replicates the core logic of the Make.com scenario in a single Markdown file:

# Routine: Sheets-to-Slack Enrichment Pipeline

## Objective
Read new entries from a Google Sheets export, enrich each row with company data from an external API, filter based on a value threshold, and post a formatted summary to Slack.

## Prerequisites
- Environment variables: `ENRICHMENT_API_KEY`, `SLACK_WEBHOOK_URL`
- Input: `./data/new-leads.csv` (exported from Google Sheets or fetched via Sheets API)

## Steps

### Step 1 — Fetch and Parse the Sheet Data
Read `./data/new-leads.csv`. Parse it into structured records. Each row should have: `company_name`, `contact_email`, `deal_value`. Log the total number of rows found.

### Step 2 — Enrich Each Row via API
For each row, URL-encode the company name to prevent injection, then call the enrichment API using curl:

```
# URL-encode company_name to prevent injection via malicious CSV values
encoded_company=$(python3 -c "import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1]))" "$company_name")

# Replace api.example.com with your actual enrichment API endpoint
curl -sS --fail \
  -H "Authorization: Bearer $ENRICHMENT_API_KEY" \
  "https://api.example.com/v1/company?name=${encoded_company}"
```

Extract the `industry`, `employee_count`, and `funding_stage` fields from the JSON response. Add them to the row record. If the API returns a non-200 status or the curl command fails, log the company name and skip that row.

### Step 3 — Apply Conditional Logic
Filter the enriched rows: only keep rows where `deal_value` is greater than 10000 AND `employee_count` is greater than 50. Log how many rows passed the filter and how many were excluded.

### Step 4 — Format the Slack Message
For each qualifying row, create a formatted block:
- **Company:** {company_name}
- **Contact:** {contact_email}
- **Deal Value:** ${deal_value}
- **Industry:** {industry}
- **Funding Stage:** {funding_stage}

Combine all blocks into a single Slack message with a header: "🔔 New Qualified Leads — {date}"

### Step 5 — Post to Slack
Verify that the `SLACK_WEBHOOK_URL` environment variable is set. Construct the JSON payload safely using jq to avoid injection issues, then send to Slack:

```
# Guard: verify required variable is set before use
[[ -n "$SLACK_WEBHOOK_URL" ]] || { echo "ERROR: SLACK_WEBHOOK_URL is not set" >&2; exit 1; }

payload=$(jq -n --arg msg "$formatted_message" '{"text": $msg}')

if ! curl -sS --fail -X POST \
     -H "Content-Type: application/json" \
     -d "$payload" \
     "$SLACK_WEBHOOK_URL"; then
  echo "ERROR: Slack post failed. Writing fallback." >&2
  printf '%s
' "$formatted_message" > ./data/slack-fallback.txt
  exit 1
fi
```

> **Security note:** Always use `jq` or a similar tool to construct JSON payloads rather than string interpolation, to prevent injection vulnerabilities and malformed JSON from message content containing special characters.

Log the Slack API response status. If it fails, write the formatted message to `./data/slack-fallback.txt` as a backup.

## Error Handling
- API rate limits (429 responses): wait 30 seconds and retry up to 3 times.
- If the CSV file is empty or missing, log a warning and exit gracefully.
- If Slack posting fails after retries, save output locally and exit with a non-zero status code.

## Permissions
- File system: read/write within `./data/`
- Shell commands: `curl`, `jq`, `python3`

Step 2: Execute and Test the Routine

Run the routine from your terminal. Claude Code reads the Markdown instructions and executes each step using its tool use capabilities:

claude routines run sheets-to-slack-enrichment

Claude’s reasoning is visible in the terminal output, showing exactly which decisions it made at each step and why specific rows were included or excluded. This transparency surpasses the visual log inspection required in Make.com, where you must click through each module’s output individually.

Step 3: Schedule It

Without a built-in scheduler, routines need an external trigger. A cron job or CI/CD pipeline handles this cleanly:

0 9 * * 1-5 set -euo pipefail; cd /path/to/your/lead-pipeline && /usr/local/bin/claude routines run sheets-to-slack-enrichment >> /var/log/routines/pipeline.log 2>&1

Consider adding a logrotate configuration to prevent unbounded log growth:

/var/log/routines/pipeline.log {
    daily
    rotate 14
    compress
    missingok
    notifempty
}

name: Sheets-to-Slack Enrichment
on:
  schedule:
    - cron: '0 14 * * 1-5'  
  workflow_dispatch:           

jobs:
  run-routine:
    runs-on: ubuntu-latest
    timeout-minutes: 15
    permissions:
      contents: read
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  
      - name: Enforce Node.js >= 18
        run: |
          node_major=$(node --version | sed 's/v//' | cut -d. -f1)
          [ "$node_major" -ge 18 ] || { echo "Node.js 18+ required"; exit 1; }
      - name: Install Claude Code CLI
        run: npm install -g @anthropic-ai/claude-code@1.0.0  
      - name: Verify CLI authentication
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: claude --version
      - name: Run enrichment routine
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          ENRICHMENT_API_KEY: ${{ secrets.ENRICHMENT_API_KEY }}
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
        run: claude routines run sheets-to-slack-enrichment

Note: The Claude Code CLI automatically uses the ANTHROPIC_API_KEY environment variable when set. Verify this behavior against your installed CLI version.

Chaining Routines Together

Routines can reference other routines, enabling modular, composable workflows. A “data validation” routine produces a clean output file that a “notification” routine then consumes. This mirrors the single-responsibility principle: each routine does one thing well, and you orchestrate by calling routines in sequence or writing a parent routine that invokes child routines in order. Consult the Claude Code documentation for the routine-chaining syntax, as it may vary by CLI version. This composability is difficult to achieve in Make.com, where the default scenario structure is less modular (sub-scenarios exist but offer limited composability compared to file-based routine chaining).

AI-Native Decision Making

The direct benefit: Claude reasons at every step without a separate API call to an external AI endpoint. A routine can instruct Claude to classify incoming support tickets by urgency, summarize long-form content into a specific format, detect anomalies in numerical data, or make judgment calls about whether an edge case should be escalated. Accuracy depends on prompt specificity; test classification against labeled samples before deploying. In Make.com or n8n, achieving this requires configuring an HTTP module or dedicated AI node, managing API keys separately, and parsing the response. In a routine, it is simply another instruction in the same Markdown file.

Error Handling and Retries

Routines handle failures through natural language instructions. Specifying “if this API call returns a 5xx error, wait 60 seconds and retry up to 3 times, then log the failure and continue” gets interpreted and run by Claude without requiring custom retry logic in code. Fallback paths (“if Slack posting fails, write to a local file and send an email alert instead”) are equally straightforward to define.

Note: Natural language error handling is interpreted by Claude at runtime. The mechanism (e.g., whether Claude emits retry shell commands or loops internally) should be validated against your specific Claude Code version before production use. For critical workflows, supplement natural language instructions with explicit shell-level error handling scripts to ensure deterministic behavior.

Cost Analysis: Real Numbers from a Real Migration

A Side-by-Side Monthly Breakdown

For a team running 10 automated workflows with approximately 5,000 total runs per month, the cost comparison breaks down as follows:

Make.com on its Pro plan costs approximately $119 per month, with the risk of overage charges if operations counts spike (pricing as of early 2025; verify current plans at make.com/pricing). n8n Cloud on a Starter-level plan costs roughly $80 per month (verify current plans at n8n.io/pricing). Claude Code routines, priced on token consumption, come in at approximately $15 to $25 per month for equivalent workloads. This estimate assumes moderate-complexity routines using a Claude Sonnet-class model; verify current per-token pricing at anthropic.com/pricing.

Disclaimer: All pricing figures are approximate and subject to change. The Claude Code cost estimate assumes moderate-complexity routines averaging typical token volumes per run. Your actual costs will depend on model selection, input/output token ratios, and data volume. Set up spend alerts or API usage caps through your Anthropic dashboard.

Annualized, you save roughly $1,100 to $1,250 compared to Make.com and $660 to $780 compared to n8n Cloud. These savings estimates inherit all uncertainty from the base pricing figures cited above. At higher volumes, the gap widens: at 20,000 runs/month, Make.com Pro overage charges can double the base cost, while token costs grow linearly with usage.

Start by auditing existing workflows. Categorize each by complexity: simple linear, branching, or multi-service orchestration. This tells you which routines to tackle first and where to expect friction.

Next, identify all external API dependencies and their authentication methods. Pay special attention to OAuth flows that may need manual token management outside a visual platform. OAuth configuration is a known gap when migrating from platforms with built-in OAuth modules, so plan to implement token refresh logic separately.

Convert each scenario or workflow into a routine Markdown file, starting with the simplest to build confidence. Test routines locally against real data before scheduling automated runs. Once you trust the output, set up monitoring: direct log outputs to files or a logging service and configure error alerts.

Decommission the old platform incrementally. Run both systems in parallel during the transition period to verify output parity before cutting over.

The Shift from Visual Automation to AI-Native Workflows

Claude Code routines are not simply a cheaper way to do the same thing. They store workflows as Markdown, run AI reasoning per step, and live in Git. Make.com and n8n support none of this natively. Routine definitions sit alongside application code, version-controlled and diffable. They carry no platform-specific abstractions.

For developers comfortable in the terminal, this approach eliminates an entire category of SaaS dependency. AI-native tooling will continue absorbing tasks previously handled by standalone platforms. Pick one existing workflow, migrate it to a routine, and measure the cost and flexibility difference against your current setup. The tradeoff is real: you gain transparency and cost control, but you lose pre-built connectors and visual debugging. Whether that tradeoff works depends on your team.