Make.com + Claude Code: Automate Code Reviews and Deploy Pipelines

Claude can review your pull requests without you touching a single IDE plugin. Connect Make.com to GitHub and Anthropic's API, and every new PR triggers an automated code review posted back as a GitHub comment within seconds.

A quick note on naming: this pipeline calls the Claude API (the Messages endpoint) from Make.com. That is different from Claude Code, Anthropic's agentic coding tool that runs in your terminal, IDE, and CI. You do not need a Claude Code subscription to build this. You need an Anthropic API key. If you also use Claude Code, it can run the same review locally or in GitHub Actions, but the no-code Make.com path below is the focus here.

This tutorial builds that pipeline end-to-end: GitHub webhook → Make.com scenario → Claude API analysis → GitHub comment. No boilerplate servers, no custom CI jobs.

Contains affiliate links. Disclosure.

Why Automate Code Reviews with Make.com and Claude?

Manual code review is the single biggest bottleneck in most engineering teams. A developer opens a PR and waits hours, sometimes days, before anyone reads it. By the time feedback arrives, the author has context-switched three times.

Claude (current models in May 2026: Claude Sonnet 4.6, Opus 4.7, and Haiku 4.5) handles code analysis well. It understands language semantics, detects logic bugs, spots security misconfigurations, and produces structured review feedback consistently. Treat it as a fast first pass, not a replacement for human review.

Make.com is the glue. It handles the GitHub webhook, extracts the PR diff, calls Claude's Messages API, parses the response, and posts the review comment, all in a visual no-code scenario. No server to maintain, no credentials to manage beyond a few API keys.

Tool	Role
GitHub Webhooks	Trigger on pull_request event
Make.com HTTP module	Fetch the raw diff from GitHub API
Make.com Anthropic module	Send diff to Claude for analysis
Make.com GitHub module	Post review comment on the PR

Who this is for: engineering teams that want consistent first-pass reviews without adding CI infrastructure, solo developers who want a second pair of eyes on every commit, and technical leads enforcing code standards across multiple repos.

---

Prerequisites

Before building the scenario, collect:

1. GitHub Personal Access Token: needs repo scope (read PR details, write issue comments). Generate at GitHub → Settings → Developer Settings → Personal Access Tokens → Fine-grained tokens.
2. Anthropic API Key: from console.anthropic.com. For code review, claude-sonnet-4-6 gives the best balance of quality and cost. API pricing for Sonnet 4.6 is $3 per million input tokens and $15 per million output tokens as of May 2026, so a typical PR review with a 1,000-token diff costs well under $0.02. If you want the cheapest option, claude-haiku-4-5-20251001 ($1/$5 per million tokens) is fine for lightweight reviews; reach for claude-opus-4-7 only when you need the strongest reasoning on complex changes.
3. Make.com account: the free tier supports up to 1,000 operations/month. For teams with active PR volume, a paid plan such as Core is enough. Verify current Make pricing on make.com. Sign up here.

Pricing verified June 2026. Plans change frequently — check the vendor’s official pricing page for current rates.

---

Step 1: Create the Make.com Scenario

Open Make.com and create a new scenario. The complete flow has five modules:

[Webhook Trigger] → [GitHub: Get PR Diff] → [Claude: Analyze Code] → [GitHub: Post Comment] → [Filter: Error Handling]

1.1 Add a Custom Webhook Trigger

1. Click + Add module and select Webhooks → Custom webhook.
2. Click Add to create a new webhook endpoint. Make.com generates a unique URL like https://hook.eu2.make.com/abc123xyz.
3. Copy this URL. You'll register it with GitHub in the next step.
4. Set Data structure to auto-detect (Make.com will infer it from the first payload).

1.2 Register the Webhook on GitHub

Navigate to your GitHub repository:

1. Go to Settings → Webhooks → Add webhook.
2. Paste the Make.com webhook URL into Payload URL.
3. Set Content type to application/json.
4. Under Which events would you like to trigger this webhook?, select Let me select individual events and check Pull requests.
5. Ensure Active is checked and click Add webhook.

GitHub will immediately send a ping event to Make.com. Open the Make.com scenario, click Run once, and confirm the ping is received and parsed.

---

Step 2: Fetch the PR Diff from GitHub API

After the webhook fires, the next module fetches the actual code diff. The GitHub API returns diffs in application/vnd.github.v3.diff format.

2.1 Configure the HTTP Module

Add an HTTP → Make a request module:

Field	Value
URL	https://api.github.com/repos/{{1.body.repository.full_name}}/pulls/{{1.body.number}}
Method	GET
Header: Authorization	Bearer YOUR_GITHUB_TOKEN
Header: Accept	application/vnd.github.v3.diff
Header: X-GitHub-Api-Version	2022-11-28

The {{1.body.repository.full_name}} and {{1.body.number}} variables are mapped from the webhook payload. Make.com populates them automatically after the first test run.

Handling large diffs: GitHub diffs for large PRs can exceed 10,000 lines. Claude's context window handles this comfortably (Claude Sonnet 4.6 supports a 1M-token context window), but you should still add a size guard to control cost and keep reviews focused. Add a Filter module between the webhook and HTTP call:

Condition: {{1.body.pull_request.additions + 1.body.pull_request.deletions}} < 3000

For PRs exceeding this threshold, skip the analysis and post a fallback comment: "PR is too large for automated review. Please request a human reviewer."

---

Step 3: Send the Diff to Claude for Analysis

This is the core of the pipeline. Make.com's Anthropic module (or a generic HTTP module pointing to api.anthropic.com/v1/messages) sends the diff and a structured review prompt to Claude.

3.1 Configure the Anthropic Module

If Make.com's native Anthropic module is available in your account, use it. Otherwise, use HTTP → Make a request:

Field	Value
URL	https://api.anthropic.com/v1/messages
Method	POST
Header: x-api-key	YOUR_ANTHROPIC_API_KEY
Header: anthropic-version	2023-06-01
Header: Content-Type	application/json

Request body (JSON):

{
  "model": "claude-sonnet-4-6",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": "You are a senior software engineer reviewing a pull request. Analyze the following diff and provide:\n1. A 2-3 sentence summary of what changed\n2. Any bugs, security issues, or logic errors\n3. Code style or readability improvements\n4. A final verdict: APPROVED, REQUEST CHANGES, or COMMENT\n\nBe direct and specific. Reference line numbers where possible.\n\nDiff:\n{{2.data}}"
    }
  ]
}

The {{2.data}} variable maps to the raw diff text returned by the HTTP module in Step 2.

3.2 Customize the Review Prompt

The prompt above is general-purpose. Tailor it to your stack:

For TypeScript/React codebases, add:

Focus on: TypeScript type safety violations, React hook dependency arrays, missing null checks, and component re-render inefficiencies.

For Python/Django:

Focus on: ORM query optimization (N+1 patterns), missing type hints, unsafe deserialization, and Django security settings (CSRF, SQL injection vectors).

For Infrastructure/Terraform:

Focus on: overly permissive IAM policies, public S3 bucket configurations, unencrypted storage, and resource naming conventions.

---

Step 4: Post the Review Comment to GitHub

Parse Claude's response and post it as a GitHub PR comment.

4.1 Extract the Review Text

Claude's API returns a JSON object with this structure:

{
  "content": [{ "type": "text", "text": "Your review text here..." }]
}

In Make.com, map the text field as {{3.body.content[1].text}} (index [1] selects the first content block). Use the Tools → Set variable module to store it cleanly before passing it to GitHub.

4.2 Configure the GitHub Comment Module

Add an HTTP → Make a request module:

Field	Value
URL	https://api.github.com/repos/{{1.body.repository.full_name}}/issues/{{1.body.number}}/comments
Method	POST
Header: Authorization	Bearer YOUR_GITHUB_TOKEN
Header: Content-Type	application/json

Request body:

{
  "body": "## 🤖 Automated Code Review\n\n{{4.reviewText}}\n\n---\n*Reviewed by Claude (claude-sonnet-4-6) via Make.com*"
}

The comment appears directly on the PR timeline, tagged with the 🤖 Automated Code Review header so engineers know immediately this is an AI review.

---

Step 5: Add Error Handling and Filters

A production-grade scenario needs three safeguards:

5.1 Filter Draft PRs

Draft PRs typically aren't ready for review. Add a filter immediately after the webhook trigger:

Condition: {{1.body.pull_request.draft}} = false
AND
{{1.body.action}} = "opened" OR {{1.body.action}} = "synchronize"

This ensures the scenario only runs when a non-draft PR is opened or updated with new commits.

5.2 Handle API Errors

Wrap the Claude API call in Make.com's error handling:

1. Right-click the Anthropic HTTP module → Add error handler.
2. Select Resume and connect a GitHub comment module that posts: "Automated review failed. Manual review required."
3. Add a Slack/email notification so the team knows the pipeline errored.

5.3 Skip Bot PRs

Dependabot and Renovate open hundreds of PRs. Skip them:

Condition: {{1.body.pull_request.user.type}} != "Bot"

---

Full Scenario Walkthrough

Here's the complete data flow when a developer opens a PR:

1. GitHub fires a pull_request webhook (action: "opened") to Make.com.
2. Make.com evaluates filters: is it a draft? Is the author a bot? Does it exceed 3,000 changed lines?
3. HTTP module fetches the raw diff from api.github.com/repos/.../pulls/{number} with Accept: application/vnd.github.v3.diff.
4. Anthropic API call sends the diff + review prompt. Claude returns structured feedback in ~3-8 seconds.
5. GitHub comment module posts the review to the PR thread.

Total latency: 5-15 seconds from PR open to review comment appearing.

---

Going Further: Deploy Pipeline Automation

The same Make.com scenario architecture handles deployment triggers. Extend the pipeline:

Automated Deploy on PR Merge

Add a second scenario triggered by pull_request with action: "closed" and merged: true:

1. Webhook → filter: {{1.body.pull_request.merged}} = true AND base branch = main.
2. HTTP module → POST to your deployment API (Vercel, Railway, Render, AWS CodePipeline).
3. Slack notification → post deploy confirmation with commit SHA and environment URL.

Claude-Gated Deployments

Combine both flows: Claude's review verdict gates the deploy. If Claude returns REQUEST CHANGES, the merge is blocked via a GitHub Required Status Check (set via GitHub's Commit Statuses API). Only APPROVED verdicts unlock the merge button.

This requires one additional Make.com module: HTTP → POST to api.github.com/repos/.../statuses/{sha} with the Claude verdict mapped to "state": "success" or "state": "failure".

---

Make.com vs. Alternatives for This Pipeline

Tool	Pros	Cons	Best For
Make.com	Visual builder, 1,000+ app connectors, good free tier	Scenario logic can get complex at scale	Teams wanting no-code setup
n8n	Self-hosted, open-source, code nodes	Requires server management	DevOps teams with infra budget
GitHub Actions	Native to GitHub, full CI/CD	YAML-only, no visual builder	Teams already in GitHub Actions
Zapier	Easiest UX	30-second timeout kills async flows	Simple, fast workflows only

For this specific pipeline, Make.com wins on balance: the visual scenario builder makes the multi-step HTTP flow debuggable without writing YAML, and the pricing scales linearly with PR volume.

---

Troubleshooting Common Issues

Webhook not firing: Confirm the GitHub webhook shows green delivery status in Settings → Webhooks → Recent Deliveries. The most common cause is a Make.com scenario that isn't set to On (active).

Claude returning empty content: Check that max_tokens is at least 512. A 1024-token budget covers most PR diffs under 200 lines.

GitHub 422 on comment POST: This usually means the PR was merged before the comment was posted. Add error handling to catch 422 Unprocessable Entity responses and skip gracefully.

Diff too large to parse: The raw diff format includes file headers and context lines. For very large PRs, use the GitHub Pulls API with Accept: application/json and cherry-pick only the patch field from changed files. This reduces payload size significantly.

---

Frequently Asked Questions

Yes. Current Claude models (Claude Sonnet 4.6 for balance, Haiku 4.5 for cheap reviews, Opus 4.7 for the hardest cases) handle code review well. Claude understands language semantics, detects bugs and security issues, and produces structured feedback. It is not a dedicated code review tool, but its general reasoning makes it effective for first-pass automated reviews. The key is a well-structured prompt that specifies your review criteria. Note that this Make.com pipeline calls the Claude API, which is separate from Claude Code, Anthropic's agentic coding tool.

Build a Make.com scenario with four modules: a Custom Webhook trigger (registered on GitHub), an HTTP module that fetches the PR diff from the GitHub API, an HTTP module that calls the Anthropic API with the diff, and a GitHub HTTP module that posts the review as a PR comment. The full build takes about 30 minutes.

Yes. Make.com includes native GitHub modules for common operations (create issue, add label, list commits). For PR diff fetching and Commit Status updates, you'll use the generic HTTP module since those endpoints aren't covered by the native modules.

Two parts: Make.com operations and Anthropic API tokens. A single PR review consumes roughly 4 to 5 Make.com operations, which fits comfortably inside a low-cost paid plan (check make.com for current tiers). On the API side, Claude Sonnet 4.6 is $3 per million input tokens and $15 per million output tokens, so an average 1,000-token diff costs well under $0.02 per review. Use Haiku 4.5 ($1/$5 per million) to cut that further. For a team of 10 developers opening 10 PRs/day, API spend stays in single-digit dollars per month.

Add a Make.com filter that checks the combined additions + deletions count before calling Claude. For PRs above your threshold (e.g., 3,000 changed lines), skip the analysis and post a fixed comment directing developers to request a human review. You can also use the GitHub API to fetch diffs file-by-file and only analyze files matching specific patterns (e.g., skip lock files, only review *.ts files).

Yes. Parse Claude's response to extract the verdict keyword (APPROVED / REQUEST CHANGES). Then call the GitHub Commit Statuses API (POST to /repos/{owner}/{repo}/statuses/{sha}) with state: success for approved and state: failure for changes requested. Combine this with a GitHub Branch Protection Rule that requires this status check before merging.

---

Start Automating Today

Every PR your team opens without automated first-pass review is latency you're adding to your shipping cycle. The Make.com + Claude pipeline eliminates that bottleneck in under an hour of setup.

If you don't have an Anthropic API key yet and want to test the review prompts interactively first, you can try Claude free for a week and iterate on the prompt before wiring it into Make.com.

Create your free Make.com account. The free tier covers up to 1,000 operations/month, enough for a small team to run this pipeline at no cost.

For more automation patterns, see how n8n handles async Apify pipelines and the guide to building MCP servers for developer tooling.