CodeReview Crew

💡 Inspiration

Code reviews are fundamentally broken. Today, developers rely on a single "AI reviewer" or static analysis tools that spit out generic, noisy, and context-ignorant feedback. But in the real world, human code reviews aren't done by one person—they involve security experts, performance geeks, and strict linters all chiming in to debate the code.

We were inspired by the concept of Swarm Intelligence. What if, instead of asking one generic AI to do everything, we deployed an entire team of highly specialized, hyper-focused AI agents—each with distinct personalities, goals, and constraints—to collaborate on reviewing a repository? Thus, Code Review Crew was born.

🚀 What it does

Code Review Crew is a next-generation, agentic code review platform. When a developer selects files from their repository, the platform unleashes a "Swarm" of 8 highly specialized AI Agents (including the Security Sentinel, Performance Profiler, and Code Purist).

The Swarm analyzes dependencies, logic flaws, and architectural bottlenecks, streaming rich, context-aware feedback to the UI in real-time. But we didn't stop at just identifying bugs. Developers can open a live chat with the specific agent that flagged an issue to debate the finding. Once satisfied, they can click "Apply Fix," and our backend intelligently patches the code, creates a new branch, and instantly opens a Pull Request on their GitHub repository.

🛠️ How we built it

We built the platform with a hyper-focus on a premium, enterprise-ready architecture:

• Frontend: Next.js, React, and Tailwind CSS power the gorgeous "Bento Box" UI. We integrated react-force-graph-2d utilizing the HTML5 Canvas API to render an interactive, physics-based repository dependency graph so developers can visualize their codebase instantly.
• Backend: A high-performance Python FastAPI server leverages asyncio and Server-Sent Events (SSE) to stream the massive volume of agent responses to the client in real-time without blocking.
• Google Cloud & Gemini 2.5 Flash: This is where the magic happens. We chose Gemini 2.5 Flash because an 8-agent swarm requires executing dozens of LLM calls concurrently, and Flash delivered the unprecedented speed we needed. We utilized Gemini System Instructions to strictly enforce the unique personas of our 8 agents, ensuring the Security Sentinel only hunts for vulnerabilities while the Code Purist argues about SOLID principles. A 9th agent—the Lead Reviewer—acts as the aggregator to deduplicate findings.
• RAG Integration: We inject deep repository context into our workflow via RAG, ensuring the swarm delivers hyper-accurate, project-specific insights rather than generic advice.

🚧 Challenges we ran into & How we solved them

1. Latency in Multi-Agent Orchestration

• Issue: Firing 8 different AI models simultaneously caused massive HTTP timeouts and a terrible UX when waiting for the final result.
• Solution: We migrated from standard request-response to an asynchronous Server-Sent Events (SSE) pipeline. As soon as any individual agent finishes its analysis via asyncio, it streams that finding immediately to the Next.js frontend, creating a blazing-fast, staggered UI reveal.

2. Brittle Auto-Fixes and Fuzzy Diffs

• Issue: When agents suggested code fixes, the generated unified diffs were sometimes slightly "fuzzy" or improperly formatted, causing standard patching libraries to fail and crash our GitHub PR pipeline.
• Solution: We built a two-step resilient patching engine. First, it attempts a strict deterministic patch. If that fails, it falls back to Gemini 2.5 Flash as an intelligent merge engine—passing the broken diff and the original file to Gemini to perfectly weave the fix into the code before pushing the commit to GitHub.

3. Rendering Massive Repositories

• Issue: Rendering an entire enterprise repository as a physics graph caused severe UI lag and text-overlapping issues in the browser.
• Solution: We wrote custom canvas rendering logic that dynamically calculates the viewport, fading node labels in and out based on the user's current zoom level to maintain 60FPS performance.

🏆 Accomplishments that we're proud of

We are incredibly proud of successfully orchestrating a true Agentic Architecture. Most projects claim to be "multi-agent" but are just a chain of sequential prompts. We built a genuine Swarm where agents operate concurrently and a Lead Reviewer synthesizes the debate.

Furthermore, we are proud of the UX/UI. Hackathon projects often look like rough prototypes, but Code Review Crew feels like a premium, enterprise-grade SaaS product right out of the box.

🧠 What we learned

We learned that Multi-Agent Architectures are the future of software engineering. Prompting one massive model to "review this code" yields average results. Breaking the task down into 8 highly constrained, persona-driven prompts powered by Gemini 2.5 Flash resulted in dramatically higher-quality code reviews with near-zero hallucinations.

🔮 What's next for Code Review Crew

We want to integrate Code Review Crew directly into the CI/CD pipeline (GitHub Actions / GitLab CI) so the Swarm can automatically intercept Pull Requests, debate the code changes in the background, and leave automated inline comments before a human reviewer even looks at it!

Built With

• fast-api
• gcp
• google-adk
• google-gemini
• nextjs
• server-sent-events