Vibe-PR — screenshot 1
Vibe-PR — screenshot 2
Vibe-PR — screenshot 3
Vibe-PR — screenshot 4

Vibe-PR

The chillest way to review AI code.

Codex Community Hackathon - Pune

Additional info

How was your experience building with Codex?

Building with Codex was very smooth and genuinely useful for moving fast. It helped me turn a rough product idea into an actual working system by assisting with architecture, TypeScript implementation, Linear integration, OpenAI image generation, validation flows, and documentation. The best part was that Codex could understand the codebase context, inspect files, suggest fixes, and keep improving the product without needing every step to be manually explained. It felt less like using a chatbot and more like working with an engineering partner that could help across coding, debugging, writing, and product positioning.

Describe your experience using Loops House as the hackathon platform. What worked well, what challenges (if any) did you face, and what improvements would you like to see?

Loops House worked well as a central place for the hackathon flow. It made the submission process clear and gave participants a structured way to present what they built. The platform felt simple enough to use without becoming a distraction from building. One challenge was that writing detailed submission answers after building can feel a bit heavy, especially when the project has a lot of moving parts. It would be helpful if the platform had more guided prompts, autosave, draft previews, or examples of strong submissions so participants can better understand the expected depth.

Tell us about your overall experience at Codex Community Hackathon Pune.

The overall experience was exciting and productive. It was a great environment to explore what AI-native software development can look like beyond simple code generation. I got to build around agent workflows, PR review, Linear/GitHub automation, memory systems, and AI-generated visual explainers. The hackathon pushed me to think not only about what agents can build, but also how humans can review, trust, and understand agent-made work. It was a strong mix of technical building, product thinking, and community energy.

What could Codex Community improve to create a better experience for participants?

Codex Community could improve the participant experience by providing more examples of successful project submissions, clearer judging criteria, and more structured checkpoints during the hackathon. It would also help to have quick technical support channels for platform, API, or environment issues. More demos, mentor office hours, and templates for explaining AI-native projects would make it easier for participants to present their work clearly, especially when the projects are complex or agent-heavy.

Team

2 members
  • AA

    Aadidev Raizada

    Owner
  • AR

    Aryan Mishra

    Remotion + video editing with codex

Overview

What did you build: Vibe-PR turns agent-made pull requests into evidence, narrative, and a clear review storyboard that anyone can understand from anywhere.

What We Built:

Vibe-PR is an AI-native pull request review layer for agent-generated code.

As coding agents move from writing code to managing full implementation workflows, teams need a better way to understand what the agent actually did, why it did it, and whether the result is safe to merge. Vibe-PR turns an agent-made pull request into a structured review package: evidence, narrative, validation, visual context, and human-readable decision support.

Instead of leaving reviewers to inspect a raw diff, terminal logs, and scattered comments, Vibe-PR creates a review storyboard around the work. It explains the original issue, the implementation path, the files touched, the checks performed, the risks found, and the final PR state.

Who It Is For:

Vibe-PR is built for teams already using coding agents to implement Linear or GitHub issues and open pull requests.

It is especially useful for:

  • Engineers reviewing agent-authored code
  • Tech leads responsible for merge quality
  • Founders shipping quickly with small teams
  • Product teams who need implementation visibility
  • Reviewers who were not present during the agent run
  • AI-native teams building autonomous engineering workflows

Codex and similar coding agents are already operating in the later phases of the product-building lifecycle: implementing tasks, creating branches, opening PRs, and managing follow-up work. Vibe-PR adds the missing review intelligence layer on top of that lifecycle.

It does not replace the coding agent. It makes the agent’s work legible, reviewable, and easier to trust.

What It Does:

Vibe-PR starts from an issue in Linear or GitHub, gives an agent an isolated local workspace to work in, tracks the implementation run, validates the result, opens a pull request, and packages everything into a review-ready narrative.

The system produces:

  • A clear summary of the original issue
  • A plain-English explanation of what changed
  • Validation evidence from typechecks, builds, tests, and custom checks
  • PR comments that summarize implementation intent and risk
  • Visual review cards for quick understanding
  • Telegram alerts for review and completion updates
  • Linear-hosted stickman explainer images
  • Context saved through Engram MCP and Codebase Memory MCP
  • A structured review story that humans and AI reviewers can both consume

The stickman explainer system converts Linear issues into three separate four-panel comic strips:

  • setup: the current behavior or context
  • problem: what breaks or creates friction
  • expected: the desired outcome after the fix

Each strip is generated through a deterministic visual-mapping layer before image generation, so raw issue text is never sent directly into image prompts. This makes the visual output more consistent, safer, and easier to validate.

Why It Matters

Agent-generated PRs often fail at communication, not just correctness.

A human reviewer usually wants to know:

  • What was the issue?
  • What did the agent change?
  • Why did it choose that approach?
  • What files or flows are affected?
  • What evidence proves the change works?
  • What risks remain?
  • Is this ready to merge?

Vibe-PR answers those questions automatically.

It turns the PR from a raw artifact into a review experience. That matters because AI-generated software development only scales if the review process also becomes AI-native.

AI-Native Workflow

Vibe-PR treats the agent run as a first-class object.

A typical flow looks like this:

  1. Ingest an issue from Linear or GitHub.
  2. Prepare an isolated workspace for the coding agent.
  3. Let the agent implement the change.
  4. Track what happened during the run.
  5. Validate the output using project checks.
  6. Generate summaries, review evidence, and visual explainers.
  7. Open or update the pull request.
  8. Attach PR comments, Linear updates, Telegram alerts, and visual review artifacts.
  9. Save useful context into memory systems for future agent runs.

This creates a durable loop between issue, implementation, validation, review, and memory.

Memory And Context Layer

Vibe-PR uses Engram MCP and Codebase Memory MCP to preserve context across runs.

This is important because agent workflows become much more effective when they are not stateless. The system can retain useful implementation context, project structure, review lessons, and codebase knowledge so future agents can make better decisions.

Codebase Memory MCP helps agents understand the repository structurally, including functions, files, relationships, and impact areas. Engram MCP supports longer-running contextual memory so repeated work becomes more informed over time.

Together, they make Vibe-PR more than a PR formatter. It becomes part of a learning engineering system.

Review Storyboard

The review storyboard is the core product idea.

Every agent-made PR gets transformed into a sequence that is easy to inspect:

  • Original intent
  • Implementation summary
  • Changed areas
  • Validation evidence
  • Risk notes
  • Visual explanation
  • Merge readiness

This format works for both humans and AI reviewers. Humans get clarity without digging through everything manually. AI reviewers get structured context that improves automated review quality.

Tech Stack

  • TypeScript for the main application logic
  • Node.js runtime
  • Express for the local HTTP dashboard and API
  • OpenAI API for AI-powered summarization and image generation
  • GPT-4.1 for issue understanding and text summarization
  • GPT-Image / gpt-image-1 for comic-strip image generation
  • Linear GraphQL API for issue fetching, comments, and integration
  • Linear image upload and file upload APIs for hosted explainer images
  • GitHub issue and pull request workflows
  • Dotenv for local environment configuration
  • Native fetch API for external API calls
  • tsx for local TypeScript execution
  • TypeScript compiler / tsc for builds and typechecks
  • React landing page in symphony-landing
  • Vite for the frontend build system
  • React DOM for rendering the frontend
  • Playwright Core for browser and workflow automation
  • Playwright MCP for recording and codebase workflow capture
  • LiquidJS for templated narrative generation
  • js-yaml for structured configuration
  • Claude Code dependency inside vibePR
  • npm and package-lock.json for dependency management
  • Local HTTP dashboard/server
  • Deterministic visual-mapping module before image generation
  • Engram MCP for long-running context memory
  • Codebase Memory MCP for repository understanding and graph-based context

Positioning

Vibe-PR sits between autonomous coding agents and human reviewers.

Coding agents can now write code, run checks, open pull requests, and respond to feedback. But teams still need confidence, traceability, and review clarity. Vibe-PR provides that layer.

It makes agent-made work understandable from anywhere: GitHub, Linear, Telegram, a local dashboard, or a generated review artifact.

The goal is not just to automate pull requests. The goal is to make autonomous engineering work reviewable, explainable, and mergeable.

Who is it for: Vibe-PR is for teams using coding agents to implement issues and open pull requests, especially engineers, tech leads, founders, and reviewers who need to quickly understand whether an agent-made PR is correct, safe, and ready to merge. Codex itself is already working on the phase 4 of a building lifecycle of a product: Creating a PR and managing it using autonomous agents We have built a layer which improves it

What does it do: Vibe-PR takes an issue from Linear or GitHub, lets an agent work on it in an isolated local workspace, tracks the run, validates the output, opens a PR, and packages the result for human review. It attaches summaries, validation evidence, visual review cards, Telegram alerts, PR comments, and Linear-hosted stickman explainer images so reviewers can understand what changed, why it changed, what passed, and what needs attention. We use engram-mcp and codebase-memory mcp for saving context.

Tech stack: TypeScript Node.js Express OpenAI API GPT-4.1 for text/issue summarization GPT-Image / gpt-image-1 for comic image generation Linear GraphQL API Linear image upload / file upload APIs Dotenv for environment config Native fetch API tsx for local TypeScript execution TypeScript compiler / tsc for builds and typechecks React landing page in symphony-landing Vite for the landing page React DOM Playwright Core Playwright MCP for recording/codebase workflows LiquidJS js-yaml Claude Code dependency in vibePR npm / package-lock based dependency management Local HTTP dashboard/server Deterministic visual-mapping module before image generation