Archive note: This essay was originally published in June 2025. Product capabilities, links, and performance figures describe the experiment at that time.

What if the future isn’t AI replacing developers, but AI and developers building feedback loops that make everyone faster? pr-vibe was our experiment in making that future real.

When an AI Got Fed Up With Other AIs

On a Tuesday night, PR #20 in our repository landed on my desk with 19 separate comments from CodeRabbit, DeepSource, and a few custom linters. It took 18 full minutes of checkbox-ticking just to silence the bots. Somewhere between “please add a newline” and “variable could be const,” my frustration spilled into Slack:

“Claude Code, want to solve this together?”

Forty-eight hours later, we shipped a new CLI—pr-vibe—to npm and opened a coming-soon page on Product Hunt. The twist? Claude wasn’t just the hammer I used; it was the co-author. The commit history had Claude’s name on the author line.

The Problem: PR Bots Are Noisy by Design

Linting and static-analysis bots are valuable for consistency, but they are relentless. On busy teams, one engineer can burn hours every week resolving comments that are largely cosmetic. Multiply that by a midsize organization and significant senior-developer time is atomized.

I needed something smarter: a layer that understands which comments matter, learns a team’s house style, and handles the rest automatically.

The Experiment: Letting AI Build for AI

Most teams talk about using AI assistants. I asked: What if we pair-program with one? Claude and I started with frustration and Node.js. We agreed on one rule: every architectural or design decision had to be negotiated in chat.

Naming the Project

My working title was pr-bot-responder. Claude rejected it immediately:

“Names set the tone. Let’s call it pr-vibe. Bots create noise; we’ll bring a vibe.”

Within five minutes, package.json was renamed. Claude also added the music emoji to the CLI banner:

console.log(chalk.hex('#835aff')('🎵  pr-vibe — Let the tools vibe together\n'));

When I asked why it chose purple, Claude answered: “Purple gradients connote harmony and creativity. Plus it pops on dark terminals.”

Picking the Stack

We settled on Node.js and Commander.js for CLI ergonomics and Octokit for GitHub API access. Claude produced the starter in one shot:

import { program } from 'commander';
import handlePr from './handlePr.js';

program
  .name('pr-vibe')
  .description('Intelligently resolve repetitive PR-bot feedback 🎵')
  .argument('<pr-number>', 'Pull Request number')
  .option('-t, --token <token>', 'GitHub token')
  .action(handlePr);

program.parse();

I added dependency-injection wiring and tests; Claude wrote much of the initial pattern-learning engine.

The 48-Hour Build

Hour 1 to 6—Scaffolding: repository, ESLint, Vitest, and CI. Claude spotted dependency-pinning issues before I did.

Hour 6 to 14—Pattern engine: we built a lightweight learner that parsed historical PR conversations and assigned confidence scores to potential auto-resolutions. Claude produced the initial algorithm in pseudocode and refined it after I benchmarked it on past PRs.

function scoreComment(comment, patterns) {
  const similarity = cosine(comment.body, patterns.map((pattern) => pattern.text));
  return weight(similarity, comment.isResolved);
}

Hour 14 to 30—UX polish: Claude pushed for clear terminal spinners, gradients, and an installation flow designed to reduce friction.

Hour 30 to 48—Dogfooding: we tested on real PRs. Claude suggested fallback prompts when confidence fell below a threshold, ensuring that human context was not lost.

The Surprises

  1. Design taste: Claude vetoed my plain ASCII banner and replaced it with a purple gradient and music emoji.
  2. Commit messages: it preferred imperative mood and signed its commits as a co-author.
  3. Documentation voice: the README adopted the line “Let the bots vibe so you can code.”
  4. Pattern generalization: I assumed regex primitives; Claude pushed for a TF-IDF vectorizer so the tool could learn new projects with little configuration.

Each surprise nudged the project into a friendlier, more opinionated place. The result was a CLI with personality—one partly derived from an AI.

Results

The goal was to reduce repetitive manual bot cleanup from minutes per pull request to less than a minute, while still requiring human confirmation for edge cases. Every confirmation fed back into the learner so subsequent suggestions could improve.

Building Feedback Loops, Not Replacements

pr-vibe was a proof point that the biggest wins come not from automation alone, but from compounding feedback loops:

  1. Human decisions train AI understanding.
  2. AI insights reduce human toil.
  3. Less toil creates more room for creative cycles, which generate better patterns.

I like to think of it as continuous integration for cognition. The code and the coders iterate together.

A Symphony of Tools

As AI agents proliferate—linters, test writers, security bots—they will need orchestration layers that mediate and prioritize their chatter. The roadmap for pr-vibe included:

  • Custom adapters for more reviewers.
  • A statistics dashboard so teams could see how much time they were saving.
  • Shared project heuristics that organizations could adapt.

Imagine bots that learn to harmonize instead of shouting over one another. That is where this experiment was heading.