Business Process Automation with Claude Code (2026)

The Claude Code story is a happy accident. Anthropic picked the terminal over an IDE extension for "maximum control over files." That let Claude Code execute any command, edit any file, and orchestrate processes far beyond code.

Three data points explain why usage took off outside software development:

1. Daily installs doubled in three months. From 17.7 million (30-day moving average) to 29 million. A meaningful chunk of that growth isn't developers: it's analysts, operations, marketing, and finance teams who discovered Claude Code runs flows that no Zapier covers.

2. 95% of outputs work on the first try. This matters because it shifts the mental model. In Zapier or n8n you design the flow step by step. In Claude Code you describe the goal and the tool decides the steps, executes them, verifies the result, and retries if it fails. It's the difference between dictating a procedure and delivering an expected outcome.

3. The terminal is the common denominator. Any SaaS with an API, any CRM with a CLI, any database with a command-line client is reachable from Claude Code. There's no "official integration" to wait for. If the system speaks via a command, Claude Code can orchestrate it.

The consequence: teams who spent years wrestling with Zapier boxes for a specific flow now write 30 lines of text in a file that Claude Code reads and executes.

Classic BPA tools share a model: a visual canvas, triggers, nodes, connectors. They're great for repetitive flows with few exceptions. They break down when the process needs judgment, context reading, or reaction to unforeseen situations.

Zapier. Great for simple integrations between popular apps. Limitations: 7,000 integrations but linear execution, no reasoning. Costs $20-100/month for low volumes and scales quickly to $400-2,000/month for companies with real volume.

n8n. More technical, visual canvas with code nodes. Good for technical teams wanting self-hosted and control. n8n Cloud starts at $20/month and goes up to $50-200+/month for teams. Its strong point is execution visibility: every node shows input and output.

UiPath. The enterprise RPA king. Automates graphical interfaces by replicating clicks and keystrokes. Powerful on legacy systems without APIs, but expensive (tens of thousands of $/year in licenses) and fragile when the UI changes.

Claude Code. Radically different model: you describe the process in natural language inside a skill (markdown file), define fixed rules in hooks, connect external systems with MCP servers, and the terminal executes. Included in Claude Pro ($20/month) or pay-per-use via API ($0.25 to $15 per million tokens).

The dividing line. Zapier and n8n win when the flow is deterministic and repetitive over apps with native connectors. Claude Code wins when the flow requires judgment (reviewing a contract, drafting a reply, deciding whether an invoice should be approved), when the systems have no official connector, or when the process has so many variants a visual canvas would turn into spaghetti.

Claude Code is not "a model with a CLI." It's a five-piece architecture that, when combined, enables automating complete processes. Understanding each one is the first step.

1. CLAUDE.md (the company manual). Markdown file at the project root describing context, rules, and conventions. This is where the always-true things go: folder structure, writing standards, valid IDs of internal systems. Claude Code reads this file at the start of every session and keeps it present during execution.

2. Skills (reusable procedures). Each skill is a markdown file that encapsulates a repeatable flow. Example: a `/process-invoice` skill that receives a PDF invoice, extracts data, validates against the ERP, approves if within limits, and generates an accounting entry. It's called with a single command. Claude Code loads the skill when it detects its relevance or when the user invokes it explicitly.

3. Hooks (automatic actions on events). Scripts that fire at specific lifecycle moments: before or after a tool call, at session start or end, when editing a file. Hooks make the system deterministic: "whenever you edit a config file, run the linter and notify on Slack." Without hooks, the model might forget. With hooks, the action happens no matter what.

4. MCP (Model Context Protocol). A standard protocol to connect Claude Code to external systems. There are MCP servers for GitHub, Supabase, Google Drive, Gmail, HubSpot, Salesforce, and practically any SaaS with an API. With MCP, Claude Code reads from the CRM, writes to the database, sends emails, or posts to Slack. No need to install specific plugins, just configure the MCP server.

5. Subagents (parallel workers). When a task is heavy or complex, Claude Code can launch specialized subagents in parallel. Each works with isolated context and returns results. Useful for processes with independent phases (research, draft, review) or when several flows can run simultaneously without dependencies.

The magic is in the composition. A well-designed skill uses MCP to read from the CRM, subagents to review several records in parallel, hooks to ensure every change is audited, and CLAUDE.md so everything respects company conventions.

These are real flows we've implemented with clients and in our own operation over recent months.

Case 1: Vendor invoice processing. The accountant forwards invoices to a monitored folder. A hook detects the new file and launches the `/process-invoice` skill. The skill extracts tax ID, amount, concept, and date using OCR. Validates against the ERP via MCP (vendor exists, associated purchase order, correct VAT). If everything matches and it's under the auto-approval limit, it generates the entry and notifies on Slack. If there's a discrepancy, it escalates to a human with the structured summary. Typical savings: from 8-12 minutes per invoice to under 1 minute, with full traceability.

Case 2: New employee onboarding. When a signed contract is created in the system, a hook launches the `/onboarding` skill. The skill reads the new employee's position and department, creates Google Workspace accounts (via Google Admin MCP), adds them to the matching Slack channel, emails the welcome pack, books initial training in Calendar, and creates Jira tickets for equipment and card delivery. Typical savings: from 3-4 hours of admin work per hire to 5 minutes of review.

Case 3: Expense approval above threshold. An expense request over $500 arrives by email. A hook detects the subject and triggers the `/approve-expense` skill. The skill reads the department budget, the employee's history, the internal policy, and calculates the exceptionality level. Drafts a 3-line briefing for the approver, sends it via Slack with "approve" or "reject" buttons. The response is logged in the system and notified to the requester. Typical savings: from 20-40 minutes per approval to 30 seconds of approver decision.

Case 4: Monthly client report generation. On the first day of each month, a cron-triggered hook launches the `/client-report` skill. The skill pulls analytics, CRM, and support data via MCP, calculates key metrics, drafts the report in executive format following the account's template, generates the PDF, and emails it to the client with a summary in the body. Typical savings: from 2-3 hours per report (previously distributed across multiple people) to 15 minutes of final review.

Case 5: Automated content publishing (our own operation). This is the pipeline we use at 91 Agency to publish blog posts. A `/publish-blog` skill reads the queue of pending topics, researches via WebSearch, writes bilingual content, validates against style rules, creates the TypeScript data file, registers the post in the index, runs the build, commits, and opens a pull request on GitHub. The human only reviews the PR before merge. Cadence: a complete new post in 10-15 minutes of model work, with 5 minutes of human review.

This is the method we use with clients. It works best when applied to a concrete process, not in the abstract.

Step 1: Map the process before automating it. Draw the current flow as it is, with decisions and exceptions. Identify which steps require judgment (potential AI), which are pure system (APIs and MCP), and which are formalities (deterministic hooks). If you can't sketch the process on a sheet, Claude Code won't fix it.

Step 2: Start with the skill, not the infrastructure. Write the markdown file describing the process in natural language. Include goals, inputs, outputs, business rules, and what to do in each exception. The skill is the minimum reusable unit. If you can't express the process as coherent text, the model can't execute it either.

Step 3: Connect systems with MCP. Install the required MCP servers (Gmail, Google Drive, Supabase, CRM, whatever fits). Test that Claude Code can read and write to each system before wiring it into the flow. MCP integrations are often the point where projects get stuck if left for last.

Step 4: Lock in invariants with hooks. Everything that must happen no matter what (audit log, error notification, human review above critical thresholds) goes into hooks. Hooks are code, not prompts. If the flow can compromise sensitive data or has financial implications, every critical action should have an associated hook.

Step 5: Deploy in assisted mode before autonomous mode. During the first weeks, every skill execution should be reviewed by a human before irreversible actions run. Use Claude Code with manual approval. Once the success rate is stable (usually after 20-50 executions), switch to autonomous mode with error alerts. Skipping this step is the fastest way to break a critical process in the first month.

Claude Code doesn't replace Zapier or n8n in every case. These are the scenarios where other tools are still better.

Use Zapier if:

- Your process is deterministic and chains popular apps (Gmail, Sheets, Slack, HubSpot) with simple logic. - Your team isn't technical and you need a GUI anyone can maintain. - Volume is low (under 10,000 executions per month) and Zapier's cost stays under $100/month.

Use n8n if:

- You need self-hosting because of internal data policy. - Your technical team prefers a visual canvas with code nodes and wants full execution visibility (what went in, what came out, where it failed). - The process has clear repetitive structure and few judgment exceptions.

Use UiPath or other RPA if:

- You have to automate legacy systems with no API, only a GUI. - Volume justifies the enterprise cost (tens of thousands of $/year). - You already have RPA investment and trained teams.

Use Claude Code if:

- The process requires judgment, context reading, or content drafting. - The systems involved have API or CLI access, even if there's no native Zapier integration. - The process has many variants that would become a maze in a visual canvas. - Your team includes at least one person comfortable with the terminal (no need to code, just no fear of a black screen). - You need the same system to automate invoices today, onboarding tomorrow, and reports the day after, without learning a different tool for each flow.

What we actually see in clients. Most end up with a combination: Zapier or n8n for simple visible flows, Claude Code for judgment flows where the return comes from output quality, not just saving clicks. It's not "pick one," it's assigning each flow to the tool that solves it best.

Claude Code pricing models are simple, but calculating the real cost of an automated flow requires understanding how each execution consumes tokens.

Pro Plan ($20/month). Includes Claude Code use with generous limits for personal or small-team use. Enough for teams automating 5-20 simple flows with low-to-medium volume.

Max Plan ($100-200/month). Extended limits, suitable for mid-size teams with frequent flows. This is the standard plan for SMBs running Claude Code most of the day.

SDK and pay-per-API. For automated flows triggered by hooks or cron (no human in session), the recommended model is API pay-per-use. Rates from $0.25 to $15 per million tokens depending on the model used (cheap Haiku, premium Opus). A `/process-invoice` skill execution typically consumes 5,000-15,000 tokens and costs between $0.01 and $0.10.

Real example: monthly cost of an SMB with 5 automated flows.

Compared to alternatives. The same five flows on Zapier (Team plan with enough executions) cost $299-599/month. On n8n Cloud Pro, $50-100/month but require weeks of node configuration per flow. On enterprise RPA, not even comparable: $5,000-15,000/year in licenses alone.

The real calculation isn't only monthly cost. It's implementation cost. A well-designed skill for a specific flow takes 2-10 hours of a technical person's work, versus 15-40 hours to build the same flow in n8n with equivalent robustness. The return is measured in months, not years.