# Add Dependabot to a Jekyll Site

Yes. An agent adds a bundler entry to your Jekyll site's dependabot.yml that groups the plugins, keeps Jekyll on its major, skips the git gem, and opens a PR.

[Run this on Rush](https://cloud.getrush.ai/run/add-dependabot/jekyll/). Opens the console with this prompt ready to send, in a Project that has your repository.

## What the agent does

The agent reads what Dependabot already does before it adds to it, since a second entry for an ecosystem that is already covered is refused. In a site laid out like github/choosealicense.com, `.github/dependabot.yml` has one `github-actions` entry at `/` on a weekly schedule, with a `cooldown` of 7 days and a `github-actions-all` group that collects every action. There is no `bundler` entry, so the `Gemfile` never moves on its own: `jekyll ~> 4.3` with `jekyll-github-metadata`, `jekyll-redirect-from`, `jekyll-seo-tag`, `jekyll-sitemap` and `jekyll-polyglot` as plugins, `webrick` for `jekyll serve`, a `development` group of three gems, and a `test` group with `html-proofer ~> 5.0`, `rake`, `rspec`, `rubocop`, `safe_yaml` and `licensee`, which is a git dependency on its `main` branch rather than a published version.

Then it reads what the lockfile and the tests expect. `Gemfile.lock` resolves `jekyll` to 4.4.1, `html-proofer` to 5.2.1, `rubocop` to 1.88.2 and `jekyll-polyglot` to 1.13.0, and ends with `BUNDLED WITH 4.0.16`; `.ruby-version` says 4.0.5, and `spec/ci_ruby_version_spec.rb` fails the suite if the `Set up Ruby` step in `test.yml` or `deploy.yml` names a different Ruby, or if `.rubocop.yml`'s `TargetRubyVersion` drifts from the minor. `script/cibuild` runs `bundle exec rake test`, which builds the site, runs the specs and runs HTMLProofer over `_site` with `enforce_https` on, then `rubocop -D -S`. `deploy.yml` builds with `BUNDLE_WITHOUT: development:test`, so a gem that moves only in those groups never reaches the published site. The `bower.json` with `hint.css` and the `license-list-XML` submodule are outside what Dependabot's bundler support updates, and the agent says so rather than configuring them.

It adds a `bundler` entry at `/` on the same weekly schedule as the actions, with the same 7-day cooldown, a `jekyll-plugins` group whose patterns are `jekyll-*` so the five plugins arrive as one pull request, a second group for the `test` gems (`html-proofer`, `rubocop`, `rspec`, `rake`), an `ignore` for `jekyll` with `version-update:semver-major` because `~> 4.3` is a deliberate ceiling and every plugin in the lockfile declares `jekyll < 5.0`, and `open-pull-requests-limit` low enough that a quiet week is one or two pull requests. Each group and ignore gets a comment naming the `Gemfile` line it comes from. The git-sourced `licensee` gets a comment too: Dependabot does not version-bump a gem pinned to a branch, so that gem keeps following `main` through `bundle update licensee` by hand.

In its sandbox the agent validates the YAML against the Dependabot configuration schema, then dry-runs the first week with `bundle outdated --groups` and `bundle outdated --only-explicit` so the pull request can say which gems the first grouped update would touch and which majors would sit behind the ignore. It runs `bundle install` and `script/cibuild` once, with the submodule checked out, so the description can state that the suite is green on the current lockfile before Dependabot starts changing it.

## Start it with one API call

`POST https://api.phoenix.so/o/{org}/sessions`

```json
{
  "agent": "claude",
  "input": "Add Dependabot version updates for RubyGems to this Jekyll site. Read .github/dependabot.yml, Gemfile, Gemfile.lock, .ruby-version, .rubocop.yml, Rakefile, script/cibuild, spec/ci_ruby_version_spec.rb and .github/workflows first. Keep the existing github-actions entry unchanged and add a bundler entry at the root on the same weekly schedule and cooldown, with a group for the jekyll-* plugins, a group for the test gems, an ignore that keeps jekyll on its current major, and a low open pull request limit. Put a comment on each group and ignore naming the Gemfile line it comes from, and note in a comment that the git-sourced licensee gem is not updated by Dependabot. Validate the file against Dependabot's configuration schema, run bundle install and bundle outdated, run script/cibuild once, and open a pull request that lists what the first grouped update would include. Do not change the Gemfile, the lockfile or any workflow.",
  "resources": [
    {
      "url": "https://github.com/your-org/your-app"
    }
  ]
}
```

1. **Get an API key.** In the console, open Settings, then API keys, and create a key for your org. Send it in the Authorization header as a Bearer token.
2. **Send the request.** POST the body in request.json to https://api.phoenix.so/o/{org}/sessions, with your repository as the resources URL. The run starts in its own cloud sandbox.
3. **Read what came back.** Follow the run on its live stream or wait for the run.completed webhook, then read the result and its trajectory.

## What comes back

The pull request changes `.github/dependabot.yml` and nothing else. Its description pastes the schema validation result, the `bundle outdated` table with the `test` and `development` gems marked, the list of gems the first `jekyll-plugins` and `test-gems` pull requests would carry, the majors held back by the ignore, and the `script/cibuild` output showing the specs, HTMLProofer and RuboCop passing on the current lockfile.

Before merging, a reviewer decides whether the weekly day suits their publishing rhythm, whether `rubocop` belongs in a group at all (a RuboCop minor can add cops that fail `cibuild` until `.rubocop.yml` is adjusted), and whether the `jekyll` major should stay ignored or move to a dedicated upgrade issue when Jekyll 5 ships.

## Run it on every Monday morning

Once Dependabot opens its grouped pull request each week, the useful run is the one that proves it. An automation on the Project with a `schedule` trigger (`cron` `0 9 * * 1` in your `timezone`) and the prompt "for each open pull request by dependabot, run bundle install and script/cibuild on its branch, and comment on it with the result and any HTMLProofer or RuboCop failure" runs once a week after Dependabot's slot; a pull request a bot opened fires no `github` trigger, so the schedule is what reaches them.

A team with several Jekyll sites sends this body once per repository from its own server, each a `POST /o/{org}/sessions` with that repository in `resources` and a `request_id` that is a UUID v5 of the repository's full name, so a retried call returns the run already started. Each run reads its own `Gemfile`: a site on the `github-pages` gem gets an ignore for that gem's pinned plugins instead, and one with no `test` group gets no second group.

## Why run it on Rush?

A Dependabot entry copied from another repository tends to let Jekyll jump a major that every plugin in the lockfile forbids, or to open five plugin pull requests that each rebuild the site. The agent reads the `Gemfile`, the lockfile's constraints and the CI script first and writes the groups and the ignore from what it found, including the gem Dependabot cannot update.

The schema check, the `bundle outdated` table and the green `cibuild` run stay with the run and are in the pull request, so the reviewer sees what the first week will propose and knows the suite passed before it did. The same request runs across every site a team maintains at once.

## Frequently asked questions

### Why does the git-sourced gem get a comment instead of an update rule?

Because `licensee` is declared with `git:` and `branch: 'main'` in the `Gemfile`, and Dependabot's bundler updater bumps published versions, not a branch pin. The lockfile records the commit it resolved, and moving it is a `bundle update licensee` someone runs when they want the newer commit. The comment keeps the next reader from wondering why that gem never appears in a Dependabot pull request.

### Will Dependabot change the Ruby version?

No. `.ruby-version`, the `ruby-version` inputs in `test.yml` and `deploy.yml` and `TargetRubyVersion` in `.rubocop.yml` are outside both entries, and `spec/ci_ruby_version_spec.rb` fails the suite if they ever disagree, so a Ruby bump stays a deliberate change that touches all four together.

### Why keep Jekyll on its major?

`~> 4.3` in the `Gemfile` already stops Bundler at 4.x, and every plugin in the lockfile declares `jekyll < 5.0`, so a Jekyll 5 pull request would fail to resolve until each plugin releases support. The ignore makes that explicit and keeps Dependabot from retrying it weekly; minors and patches within 4.x still arrive.

### Does this cover the Bower package or the submodule?

No. `bower.json` lists `hint.css` for the vendored assets, and `license-list-XML` is a git submodule; neither is in the bundler ecosystem. Dependabot has a `gitsubmodule` ecosystem that moves a submodule's pinned commit forward, and the pull request names it as an optional third entry rather than adding it unasked.

## More Jekyll jobs

- [Add a GitHub Pages Deploy Workflow to a Jekyll Site](https://getrush.ai/run/add-deploy-workflow/jekyll/)
- [Add Giscus Comments to a Jekyll Site](https://getrush.ai/run/add-giscus-comments/jekyll/)
- [Add Lighthouse CI to a Jekyll Site](https://getrush.ai/run/add-lighthouse-ci/jekyll/)

## The same job on other stacks

- [Add Dependabot to a Koa API](https://getrush.ai/run/add-dependabot/koa/)
- [Add Dependabot to a Lit Component Project](https://getrush.ai/run/add-dependabot/lit/)
- [Set Up Dependabot for a Maven Project](https://getrush.ai/run/add-dependabot/maven/)

## Keep reading

- [How a Rush run works on your repository, from request to pull request](https://getrush.ai/cloud/)
- [Compare cloud agents, agent sandboxes and AI code review](https://getrush.ai/compare/)
- [Rush pricing: Free, Pro and Max](https://getrush.ai/pricing/)
