JANI (Just AI Noting Improvements)

• 

  Logo inspired by the White Check Mark emoji, which is the one we use to tell fellow devs that the code review passed.

• 

  Project page

• 

  Review page

• 

  Custom rules

Inspiration

Every team has that one reviewer who somehow finds everything. Ours is named Jani.

When I was a Junior Software Engineer, her reviews could be humbling. I would submit a merge request feeling confident, then open the comments and wonder whether we had been looking at the same code. Even now, she still catches things I miss.

My teammates share the experience. We sometimes joke that she has a code scanner built into her eyeglasses. Questionable logic? Detected. Inconsistent patterns? Detected. That shortcut you hoped nobody would notice? Definitely detected.

But whenever she is away, something interesting happens: our merge requests receive fewer comments and get approved faster, yet our confidence in them drops. We miss having someone who looks that closely.

There is also the everyday bottleneck: everyone has their own tickets, and reviewing someone else’s work takes time. A merge request can sit waiting even when its author is ready to move forward.

That inspired JANI — Just AI Noting Improvements: an AI review companion that brings a little of that meticulous attention to GitLab merge requests, while keeping developers in control.

What it does

JANI brings AI feedback and automated checks together to help developers assess their merge requests before merging.

It combines GitLab Duo’s review of code changes with evidence from CI pipelines, tests, security scans, secret detection, and code quality reports. Developers receive a consolidated MR summary and inline comments that explain findings where they matter.

Its review outcomes distinguish between blockers, issues needing human review, no blockers found, and insufficient evidence. A missing report should never quietly become a clean bill of health.

JANI also supports the idea that every team has its own standards. Its coding standards workflow is designed to turn natural-language expectations into static checks, AI review guidance, or a combination of both, with configuration changes going through a setup MR for human review.

JANI leaves approval and merging to people. Its job is to give them useful evidence and a more informed starting point.

How we built it

We organized JANI into three repositories: a backend service, a web dashboard, and a QA project containing test scenarios and a demo application.

The backend uses TypeScript, Node.js, and Express, with Supabase PostgreSQL for persistence. The dashboard uses Next.js, and the application services run on Google Cloud Run, with container images stored in Artifact Registry.

GitLab OAuth connects users to their projects. Webhooks let the service track merge requests, pipelines, and review activity.

For the AI review, we built around a GitLab Duo custom flow. An interesting integration challenge was exchanging context and structured findings through GitLab MR notes and webhooks, allowing JANI to combine Duo’s feedback with other review evidence.

We used focused integration experiments to test assumptions before building around them, alongside seeded merge requests for repeatable review scenarios.

Challenges we ran into

Permissions became one of our biggest challenges.

Our hackathon role provided access to many capabilities, but some project settings and actions remained unavailable. We had to investigate which operations were supported, clarify restrictions with the organizers, and adjust our implementation accordingly.

For example, protected tag configuration was unavailable under the hackathon policy, so we adapted our release workflow. We also could not create the pipeline trigger token needed for isolated coding standards validation. For the hackathon, we adopted validation in the setup MR’s pipeline and deferred the isolated approach.

These constraints taught us to verify access early. A technically sound design still needs to work within the permissions of its actual environment.

Accomplishments that we're proud of

We finally started turning a long-standing idea into an application.

We had wanted to build something like JANI for a long time. What we needed was dedicated time, a deadline, and a good excuse. This hackathon gave us all three.

We are also proud of connecting the pieces: GitLab authentication, project connections, webhook processing, review evidence, Duo integration, and MR feedback. Each one brought its own questions, and getting them to work together made the idea feel real.

What we learned

This was our first hands-on experience with GitLab Duo and the Duo Agent Platform.

We learned how custom flows, triggers, service accounts, and tools fit into a development workflow—and how much experimentation matters when integrating something unfamiliar.

We also learned that a useful AI reviewer needs more than a good prompt. It needs relevant context, traceable findings, reliable delivery, and an honest way to express uncertainty. Trust depends on how clearly it handles missing evidence as much as what it catches.

What's next for JANI (Just AI Noting Improvements)

Our next priority is to harden the complete review experience through real projects and developer feedback: improve finding accuracy, reduce noise, and make every comment easier to act on.

We want to expand coding standards support, revisit isolated validation, and improve re-reviews so developers can clearly see which findings were resolved after a new commit.

Longer term, we envision integrations with more platforms and development tools, including GitHub, a CLI, and VS Code.

And perhaps, one day, JANI will come close to the scanner we suspect is hiding in our teammate’s eyeglasses.

Built With

• docker
• express.js
• next.js
• node.js
• shadcn
• supabase
• typescript