How to build a GitHub PR agent with n8n in 15 minutes

What if every GitHub pull request notification in Slack came with an instant, AI-generated summary? That automation eliminates the daily “review tax” in the process context-switching. It sounds simple enough, but building it traditionally means writing, debugging, and maintaining another script. A weekend project that quickly turns into technical debt with dependencies, configurations, and servers.

There’s a better way. Instead of code that requires constant patching, you can use a platform built for orchestrating services out of the box.

That platform is n8n.

In 15 minutes, you’ll build a fully autonomous GitHub PR agent with n8n that reads GitHub pull requests, uses Google’s Gemini AI to generate concise summaries, and posts them directly to Slack. No servers to manage. No dependencies to install. No brittle scripts to debug. Just a workflow that works.

What is n8n?#

Before we build, let’s quickly establish what n8n is and why it’s a tool you should have in your arsenal.

n8n is a source-available, visual-first workflow automation platform. It can be considered a platform for service orchestration and system integration. It provides a visual canvas for connecting APIs, databases, and services to automate complex processes.

Automated DevOps workflows#

How is this different from just writing a script? This is the key question. A script gives you infinite flexibility but leaves you responsible for everything. n8n’s philosophy is to handle the tedious, non-functional requirements of system integration so that you can focus exclusively on the business logic.

• Authentication: Instead of managing API keys in .env files, you store them once in n8n’s encrypted credential store. Nodes then use these credentials, and n8n handles complex OAuth2 token refresh flows for you automatically.

• Hosting and execution: Instead of managing a server and a cron job, you can deploy a workflow that listens for webhooks 24/7. The execution environment is built-in.

• Error handling and logging: Instead of writing try/catch blocks and setting up a logging service, every workflow execution is automatically logged. You get a full history of successes and failures, complete with the input data that caused the error, making debugging incredibly efficient.

• UI and observability: Instead of tailing log files in a terminal, you get a visual representation of your data flow, making it easy to see where a process succeeded or failed at a glance.

It’s still code behind the scenes

Crucially, “visual-first” does not mean “no code.” Every workflow you build on the canvas is a declarative JSON object. This means that you can:

• Version control your workflows in Git.

• Perform code reviews on the JSON diff.

• Programmatically generate or modify workflows via the n8n API.

It combines the speed of visual development with the professional practices of “workflows as code.”

Getting started with n8n Cloud#

The fastest way to get started with this tutorial is with n8n Cloud. The managed platform handles all the setup and infrastructure for you. They offer a free trial that provides enough power to build the bot in this guide and experiment independently. You can sign up for an n8n cloud account with a 14-day free trial.

That’s it. You’re now ready to build.

Build an AI-powered PR assistant#

Alright, let’s get hands-on. Our assistant will be a simple but powerful three-node workflow. Here’s the blueprint: a GitHub trigger will listen for new pull requests, an AI agent will use Google’s Gemini to summarize the changes, and a Slack node will post the result.

Step 1: Triggering the automation from GitHub #

First, log in to your n8n cloud account and create a new, blank workflow. The canvas’ll greet you, your visual IDE for building automations.

A workflow is built from nodes, which are the building blocks that perform specific actions. The first node we need is a trigger, which starts the workflow. Triggers are visually distinct; they have an output connector on the right but no input on the left, and are marked with an orange lightning bolt icon.

1. Select the “Add first step…” button to open the nodes panel.

2. Search for GitHub and then “on pull request.” Select this action and add it to your canvas.

Before this node can do anything, it needs permission to access your GitHub account. In n8n, we manage this securely using credentials. Think of a credential as a built-in, encrypted secrets manager. You store your API key once, and n8n handles the rest.

Step 2: Configure GitHub Credentials#

In the GitHub trigger node, select the “Credential to connect with” drop-down and choose “Create New.” You now have two options.

1. You can authenticate using OAuth:

   1. Use the “Connect my account” button. This should open a new tab.

   2. It might ask you to sign into your GitHub account if you’re not already authenticated.

   3. Once done, you can close the new tab and head back to n8n and select “Save.”

2. You can use a personal access token (PAT) from GitHub:

   1. To get one, navigate to your GitHub account and then Settings > Developer settings > Personal access tokens > Tokens (classic).

   2. Select “Generate new token (classic).” Give it a descriptive name (like n8n-pr-bot) and select the repo scope. This is important as it grants permission to read repository data.

   3. Generate the token and copy it immediately.

   4. Back in the n8n credential modal, paste the token into the “Access Token” field and select “Save.”

As we will be creating pull requests on a GitHub repository, it would be better to test this workflow on a new repository. The last thing we want is to frustrate our peers with unnecessary or dummy pull requests.

Step 3: Set Trigger Parameters#

Configure the trigger parameters on the GitHub node:

1. Resource: Repository

2. Repository owner: your-user-id

3. Repository name: your-repo-name

4. Events: Pull Request (This tells the trigger to fire when a new PR is opened.)

Finally, an important concept for development in n8n is the distinction between test and production webhook URLs. The test URL is a temporary endpoint used to capture a single sample event so you can see its data structure on the canvas. The production URL is the permanent endpoint that the workflow uses when it’s active. For now, we will work with the test URL.

Step 4: Generating the summary with Gemini#

With our trigger ready, it’s time to add the intelligence. Behind-the-scenes, n8n uses the LangChain framework and exposes its power through intuitive nodes. We’ll use a cluster of two nodes: the AI agent as the main orchestrator and the Google Gemini Chat Model as the underlying language model.

1. Select the “+” icon on the GitHub trigger node to add the next step. This adds the new node directly to the output of the first node.

2. Search for and add an AI agent node.

3. Now, we’ll connect our language model. From the configuration panel, select the “+” button under “Chat Model” and search for Google Gemini Chat Model. This is a sub-node that provides the “brain” for our agent.

4. Create your Google Gemini credential:

   1. The Gemini API is free for many use cases, making it perfect for this project.

   2. Go to Google AI Studio and select “Create API Key.”

   3. Copy the generated API key.

   4. Back in n8n, open the Google Gemini Chat Model sub-node, select “Create New” for the credential, and paste your key into the “API Key” field.

5. Once you have the credential saved, you can choose any model that you would like to use. We will be using Gemini 2.5 flash.

Step 5: Define the AI Agent’s Instructions#

An LLM’s output is only as good as its instructions. In the AI agent node, the “System Message” parameter is where we define the AI’s task. Paste in the following prompt:

Step 6: Feed the PR Data into the Agent#

We need to feed the PR’s title and body to the agent. This is where we can use expressions. This is dynamic JavaScript code inside {{ ... }} that lets you reference variables, node outputs, or run logic. As we want to pull data from the GitHub trigger that is connected to this agent node, we will reference the JSON object and access its properties. We can also drag and drop the properties from the input panel on the left into the “Input” parameter. In the AI agent’s “Input” parameter, use the following expression to combine the data from our trigger:

Step 7: Post the Result to Slack#

The final step is to post our AI-generated summary to Slack.

1. Add a Slack node after the AI agent node.

2. Create your Slack credential:

   1. Go to the Slack API Apps page and select “Create New App > From scratch.”

   2. Give it a name (e.g., PR Summary Bot) and choose your workspace.

   3. Navigate to “OAuth & Permissions.” Under Scopes > Bot Token Scopes, add the chat:write permission.

   4. At the top of the page, select “Install to Workspace” and authorize the installation.

   5. Copy the “Bot User OAuth Token” that is generated.

   6. Go back to “Basic Information” from the sidebar and copy the “Signing Secret” as well.

   7. Paste your “Bot User OAuth Token” as the “Access Token.”

   8. Under the “Signature Secret,” paste your “Signing Secret” that you copied earlier.

Configure Slack Message Parameters#

Configure the parameters on the Slack node:

1. Operation: Send

2. Send a message to: Channel

3. Channel: your-channel-name

4. Message type: Simple Text Message

Craft the final message: This is where our workflow comes together. In the Slack node’s “Text” parameter, we’ll use an expression to combine data from both the GitHub trigger and the AI agent. This shows the power of n8n’s data flow. Paste in the following expression:

This expression first inserts the AI-generated summary, then adds a well formatted link to the pull request, including the title and the author’s username. Our workflow is now complete and should be saved.

Workflow is ready!#

With our three nodes configured and connected, our workflow is complete. It’s time for the moment of truth. Let’s test the full, end-to-end automation and see our AI-powered assistant in action.

This process involves telling our n8n trigger to start listening, configuring GitHub to send events to it, and then performing the action in GitHub to trigger the workflow.

1. Start the listener in n8n:

   1. Open the GitHub trigger node and copy the production URL.

   2. On your n8n canvas, save the workflow and activate it.

   3. Select the “Execute workflow” button at the bottom of the screen. The workflow will now be in a “Waiting for trigger event” state.

2. Configure the webhook in GitHub:

   1. Navigate to your GitHub repository.

   2. Go to Settings > Webhooks and select “Add webhook.”

   3. Paste the URL from n8n into the “Payload URL” field.

   4. Change the “Content type” to application/json.

   5. Under “Which events would you like to trigger this webhook?,” select “Let me select individual events.”

   6. Uncheck “Pushes” and check the box for “Pull requests.” This ensures that the workflow only runs for PRs.

   7. Select “Add webhook.” GitHub will send a test “ping” to confirm the connection.

3. Trigger the event:

   1. Now, perform the action that our trigger is waiting for. In your repository, open a new pull request. You can do this by making a small change on a new branch. If you don’t have a branch, you can create one from your repository’s main page.

   2. Make a small change, like adding a line to the README.md and then creating a pull request to merge it into your main branch.

   3. Give the PR a descriptive title and body, for example:

      1. Title: feat: Add user profile page.

      2. Body: This PR introduces the new user profile page with an updated avatar component and settings form.

3. See the results unfold:

   1. Return to your n8n canvas. The “Listening…” state will disappear, and it will now be populated with the full JSON payload from the PR event.

   2. The workflow will execute automatically. You’ll see green checkmarks appear above each node in sequence.

   3. Now, check your Slack channel.

You should have a new Slack message from your new bot.

This is the power of a service orchestration platform. In just a few minutes, with three nodes and a few expressions, we’ve built a genuinely useful, AI-powered developer tool.

All the Perks of Automation#

Take a moment to consider what we just built in a few minutes, with zero lines of boilerplate code. A developer could spend a full day or more building a traditional script to replicate this functionality, and they would still be left with a mountain of maintenance debt.

With our three-node workflow, n8n handled the nonfunctional requirements for us automatically.

• Real-time event listening: We have a live webhook endpoint ready to receive events 24/7 without us needing to configure a server or framework.

• Secure credential management: Our API keys for GitHub, Google, and Slack are securely stored and managed by n8n. We never had to touch a .env file or worry about exposing a secret.

• Seamless AI integration: We connected to the Gemini API and got a structured response without writing a single fetch request, handling async promises, or parsing JSON.

• Observability and debugging: If any step had failed, the execution would have been logged, and the exact input data that caused the error would have been saved, making troubleshooting trivial.

This is the power of a service orchestration platform. It allows you to operate at the level of logic and ideas, connecting powerful services together like building blocks.

Taking AI workflow automation to the next level#

This AI-powered PR bot is already a huge productivity booster for code reviews. However, it’s just scratching the surface of what’s possible. A truly comprehensive developer assistant could manage the entire life cycle of work, starting with new issues.

This is where the real challenge and the real value lie. A simple PR summary is one thing, but what if you wanted to build an agent that could fully automate your issue triage process? That requires answering much more complex questions.

• Intelligent routing: How would you automatically route bug reports to one team’s Monday.com board and feature requests to a different product backlog?

• AI-powered analysis: How could the agent read a new bug report, understand its urgency from the user’s description, and automatically assign a priority level?

• Long-term memory and RAG: How could it check for potential duplicates against a knowledge base of all past issues to prevent your team from solving the same problem twice?

• Autonomous tool use: How would you give the agent a “skill,” like the ability to look up the current on-call engineer and automatically assign them the task?

• Professional deployment: How do you manage, version control with Git, and deploy this service with the same rigor as your other production applications?

Answering those questions is the difference between a helpful bot and a production-grade AI assistant. Our new course, Automate Workflows with n8n, is a comprehensive, project-based journey designed to teach you exactly that.

The PR summarizer you just built is a fantastic starting point. The full course takes these concepts to the next level, guiding you step-by-step as you build a complete GitHub issue triage agent from the ground up.

If you’re a developer or DevOps engineer looking to leverage automation and AI to eliminate toil and build powerful internal tools, this course is designed for you.

Wrapping up#

You’ve just seen how quickly you can turn a tedious developer task into an intelligent, automated service. Modern automation is a core engineering skill, and platforms like n8n are the tools that let you build powerful, reliable systems at the speed of thought. What you built today is just the beginning.