# Add Author Pages to a Jekyll Blog

Yes. An agent adds an authors data file and an author index built like the theme's tag index, links each byline to it, builds on both Jekyll versions and opens a PR.

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

## What the agent does

The agent reads how the theme already treats authors and how it builds its one existing index. In daattali/beautiful-jekyll, a post can set `author` in its front matter, as `_posts/2020-02-28-sample-markdown.md` does with `author: Bill Smith`; `_includes/header.html` prints `By <strong>{{ page.author }}</strong>` on the post, `_layouts/home.html` prints the same line in the post list, `_includes/head.html` puts it in the `author` meta tag and `og:article:author`, and `feed.xml` writes it as `dc:creator`. None of those is a link, and there is no page that lists posts by writer. `tags.html` is the model for one: a page with `layout: page` that collects `site.tags`, sorts the names, prints a button per tag and then a section per tag with every post's title and date, and the post layout links each tag to `/tags#tag`. The `CHANGELOG.md` records the `author` parameter as a recent addition, so the index is the natural next step.

It adds the data first. `_data/authors.yml` holds one entry per writer keyed by a slug, with `name`, an optional `bio`, `avatar` and `url`, so a post keeps writing the plain `author: Bill Smith` it writes today and the index matches that name to an entry. Then `authors.html` beside `tags.html`: it groups `site.posts` by `author` with Liquid's `group_by`, sorts the groups, prints one button per author and a section per author with the entry's avatar and bio when `_data/authors.yml` knows the name, and the post list under it in the same `tag-entry` markup `tags.html` uses, so the existing stylesheet covers it without a new rule. A post with no `author` is grouped under the site author from `_config.yml`, which is the fallback `head.html` already applies.

The bylines become links. In `header.html` and `home.html` the author name links to `/authors#slug`, with the slug made by `slugify` from the name, the same way the tag links are made, and `head.html` is left alone because its tags carry text, not links. The theme ships as a gem, and its gemspec selects files with a pattern that names `tags` explicitly, so the agent adds `authors` to that pattern; without it a site that installs the theme as a gem would get the link but not the page. Adding the page to `navbar-links` in `_config.yml` is left to the site owner, and the pull request shows the one line to add.

The build is the test. `.github/workflows/ci.yml` runs `bundle exec appraisal install` and then `bundle exec appraisal jekyll build --future` with `JEKYLL_ENV=production`, so the agent builds with both Jekyll 3.9.4 and 4.3.3 from `Appraisals`, confirms `_site/authors/index.html` exists on each, and reads it to check that the sample post appears under its author and that a post without an author appears under the site author. It also reads the built sample post to confirm the byline now links to the anchor the index renders.

## Start it with one API call

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

```json
{
  "agent": "claude",
  "input": "Add author pages to this Jekyll blog. Read _config.yml, the gemspec and Appraisals, tags.html, _includes/header.html, _includes/head.html, _layouts/home.html, feed.xml, the post front matter under _posts and CHANGELOG.md first. Add _data/authors.yml with one entry per writer (slug, name, optional bio, avatar and url) keyed so a post keeps using its plain author string. Add authors.html built the way tags.html is built: group site.posts by author, a button per author, a section per author with the data entry's bio and avatar when present and the post list in the same markup the tag index uses; posts with no author fall under the site author. Link the byline in header.html and home.html to /authors#slug using slugify, leave head.html's meta tags as text. Add the new page to the gemspec file pattern beside tags. Build with both Jekyll versions in Appraisals with JEKYLL_ENV=production and --future, confirm the authors page and the byline link in the built HTML, paste the output in the pull request and open it.",
  "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

A pull request that adds `_data/authors.yml` and `authors.html`, changes a line each in `_includes/header.html`, `_layouts/home.html` and the gemspec, and nothing in `_config.yml`. The description quotes both builds, the built `authors/index.html` section for the sample author, and the byline link from the built post.

A reviewer fills in `_data/authors.yml` with the real writers, since the agent can only seed it with the names it found in `_posts`, and decides whether the index belongs in `navbar-links`. They also check what happens to a name written two ways, `Bill Smith` and `bill smith`, which `group_by` keeps apart; the pull request names that as the one thing the data file cannot fix for them.

If the site is a gem user rather than this repository, the reviewer checks that their theme version includes `authors.html`, which is why the gemspec change is in the same pull request.

## Run it on every Linear issue labelled authors

New writers arrive as issues. In the console, add an automation on the Project that holds the repository with a `linear` trigger on `linear.issue.labeled` and the label `authors`, and a prompt that says: add the writer the issue names to _data/authors.yml with the bio and links it gives, build the site, and open a pull request. The issue is placed after the prompt as the event and fills in nothing, so the name and bio come from the issue text. The trigger needs a Linear connection for the automation's runner and fires only when the label is applied by someone in your Rush org.

## Why run it on Rush?

This is a small feature with three places to get wrong: the grouping, which silently splits an author written two ways; the gemspec, which decides whether gem users get the page at all; and the two Jekyll versions the theme promises to support. The agent builds both in its own sandbox and reads the generated HTML rather than assuming the Liquid did what it looks like it does.

Both builds and the read-back of the generated pages stay in the run's transcript at `GET /o/{org}/sessions/{id}/messages`, and every changed file is listed with its diff at `GET /o/{org}/p/{project}/sessions/{id}/changes`. The reviewer sees the rendered author section before the branch is deployed anywhere.

## Frequently asked questions

### Do posts have to change their front matter?

No. A post keeps `author: Bill Smith` as a plain string, which is what `header.html`, `home.html` and `feed.xml` already read. The data file maps that name to a bio and links; a name with no entry still gets a section on the index, with its posts and nothing else.

### Why a page with anchors instead of one page per author?

Because that is how this theme does tags: `tags.html` is one page with a section per tag and the post links point at `/tags#tag`, with no plugin generating pages. The same shape works on GitHub Pages without a generator plugin. A site that wants `/authors/bill-smith/` can add a page per author later, with the data file already in place.

### What about posts with several authors?

The theme treats `page.author` as one string everywhere it reads it, so the agent keeps that. A post listing two names is grouped under the combined string. Supporting a list would mean changing the byline, the meta tags and the feed together, which the pull request names as a separate change.

### Why does the gemspec change?

The theme is installed as a gem by many sites, and its gemspec picks the files to ship with a pattern that names `tags` explicitly. Without `authors` in that pattern, a gem user's byline would link to a page that does not exist.

## More Jekyll jobs

- [Add Dark Mode to a Jekyll Site](https://getrush.ai/run/add-dark-mode/jekyll/)
- [Add Dependabot to a Jekyll Site](https://getrush.ai/run/add-dependabot/jekyll/)
- [Add a GitHub Pages Deploy Workflow to a Jekyll Site](https://getrush.ai/run/add-deploy-workflow/jekyll/)

## The same job on other stacks

- [Add Author Pages to a VitePress Blog](https://getrush.ai/run/add-author-pages/vitepress/)
- [Add Author Pages to a Wagtail Blog](https://getrush.ai/run/add-author-pages/wagtail/)
- [Add Author Pages to an Astro Blog](https://getrush.ai/run/add-author-pages/astro/)

## 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/)
