DEV Community: Rishu Kumar

I Built an AI PR Reviewer That Actually Understands Next.js - Meet MergeWell

Rishu Kumar — Sun, 03 May 2026 13:52:27 +0000

Your generic linter doesn't know the difference between a Server Component and a Client Component. MergeWell does.

We've all been there.

You open a pull request at 4 PM on a Friday. Your teammate glances at the diff, sees it's a Next.js change, and approves it — because honestly, who has the bandwidth to reason through every App Router edge case under deadline pressure?

So you merge. And Saturday morning you're debugging why your Server Component is leaking session data to the client, or why your page is hydrating twice, or why use client is now at the top of a file that's pulling in a 200kb library that should never have touched the browser bundle.

Next.js is powerful. It's also genuinely complex — and most code review tools treat it like it's just React with a router bolted on. It isn't.

That's why I built MergeWell — a PR reviewer built specifically for Next.js codebases.

The Next.js Code Review Problem Is Real

Generic code review tools miss Next.js-specific mistakes entirely. They don't know that:

Adding "use client" to a component that fetches data server-side is an architectural mistake, not just a style preference
Calling cookies() or headers() inside a component that's rendered statically will silently break at runtime
Importing a heavy client-side library into the wrong boundary will bloat your bundle without a single warning in your diff
Using useEffect to fetch data in a component that could just be async is a step backwards in the App Router world
Forgetting export const dynamic = 'force-dynamic' when you need it means your page caches stale data in production

These aren't abstract concerns. They're the kinds of bugs that survive review, pass CI, reach production, and cost real time to debug. Because they're not syntax errors — they're conceptual errors that require understanding how Next.js actually works.

What Is MergeWell?

MergeWell is an AI-powered pull request reviewer built from the ground up for Next.js projects.

It reviews your diffs the way a senior Next.js engineer would — one who knows the App Router deeply, has opinions about the Pages Router, and understands the mental model shift that comes with React Server Components.

Think of it as having a Next.js specialist on your team who reviews every single PR, 24/7, without ever getting tired or distracted.

What MergeWell Catches

🧩 Server vs. Client Component Mistakes

MergeWell understands the RSC boundary. It flags when you're:

Adding "use client" unnecessarily, forcing client-side rendering where server rendering would be faster
Using browser APIs or hooks in files that run on the server
Passing non-serializable props (like functions or class instances) across the server-client boundary
Accidentally including server-only code (like database queries) in Client Components

📦 Bundle Size & Import Mistakes

Next.js's power is its ability to keep your client bundle lean. MergeWell spots when a PR is about to undo that:

Heavy libraries being imported into Client Components that should live server-side
Missing next/dynamic lazy loading for large components
Barrel imports that prevent tree-shaking

🗃️ Data Fetching Anti-Patterns

The App Router changed how we think about data fetching. MergeWell knows both worlds:

useEffect data fetching in components that should be async Server Components
Missing revalidate or incorrect caching strategies in fetch() calls
Waterfall fetches that could be parallelized with Promise.all
Redundant getServerSideProps patterns that belong in the Pages Router era

⚡ Rendering & Caching Issues

This is where Next.js gets subtle — and where most reviewers check out:

Pages that need force-dynamic but are missing it, leading to stale static renders
Incorrect use of unstable_cache or revalidatePath
Components that break static generation by opting into dynamic behavior unintentionally
Route handlers missing proper cache headers

🔒 Security Concerns Specific to Next.js

Server Actions that lack proper input validation or authorization checks
API routes missing rate limiting or CORS configuration
Environment variables being exposed to the client that should stay server-side (anything without the NEXT_PUBLIC_ prefix that's referenced in Client Components)
Middleware that could be bypassed

🏗️ App Router Architecture

MergeWell reviews structural decisions, not just line-level bugs:

Route grouping that could simplify the layout hierarchy
Layouts that re-render unnecessarily
Loading and error boundary placement
Parallel and intercepting routes used incorrectly

A Real Example

Here's the kind of thing MergeWell catches that generic reviewers miss entirely.

Imagine this gets added to your codebase in a PR:

// app/dashboard/page.tsx
"use client";

import { getUser } from "@/lib/db";

export default function DashboardPage() {
  const [user, setUser] = useState(null);

  useEffect(() => {
    getUser().then(setUser);
  }, []);

  return <div>Welcome, {user?.name}</div>;
}

A typical reviewer might see "looks fine, it fetches a user and displays it." MergeWell sees:

"use client" is unnecessary — this component has no interactivity
getUser() is a database call running client-side, which means it's either hitting an API route unnecessarily or, worse, running DB code in the browser bundle
The useEffect pattern introduces a loading flash and a waterfall
The fix is to make this an async Server Component — two lines of change, dramatic performance improvement

That's the difference between a generic review and a Next.js-aware one.

Who Is MergeWell For?

Solo Next.js developers — You're the only reviewer on your own PRs. MergeWell is the senior Next.js engineer you can't afford to hire yet.

Small teams shipping fast — Velocity is everything at an early stage. MergeWell keeps quality high without slowing you down.

Teams migrating from Pages Router to App Router — This is where mistakes happen most. MergeWell understands both paradigms and catches the conceptual mix-ups that happen mid-migration.

Open-source Next.js project maintainers — Give contributors expert-level feedback without spending hours on every PR.

Agencies building client projects — Consistent Next.js quality standards across every project, every client, every developer on your team.

Built for the Way Next.js Actually Works

MergeWell was built with one belief: a good code review tool has to deeply understand its domain.

Generic AI review tools that work on "any codebase" are useful for catching obvious bugs. But Next.js has a specific mental model — server vs. client, static vs. dynamic, caching layers, React Server Components — that requires genuine framework expertise to review well.

MergeWell isn't a linter with an AI layer. It's a reviewer that thinks in Next.js.

Try MergeWell on Your Next PR

MergeWell is live and ready for your Next.js project.

👉 mergewell.codewavelabs.org

If you're building with Next.js — whether it's a SaaS, an e-commerce site, an internal tool, or a side project — MergeWell will catch the things that slip through every other review.

Better Next.js code starts here. Let's merge well.

Built something with Next.js and ran into a review nightmare? Drop a comment — I'd love to hear about it. And if you try MergeWell, feedback is always welcome.

Tags: nextjs code-review react developer-tools ai webdev javascript typescript

The Future of SaaS Feedback: How AI Turns Conversations into Growth Engines

Rishu Kumar — Sun, 07 Sep 2025 14:36:12 +0000

In SaaS, feedback is everything. It’s the raw signal that tells you if your product is solving real problems, if your users are satisfied, and if your next feature is worth building.

But here’s the reality: most SaaS feedback loops are broken.

Surveys are ignored. Slack groups get noisy. Spreadsheets become graveyards of half-processed notes. Founders struggle to make sense of it all — and in the meantime, users churn.

This is the exact problem we set out to solve with Droon AI.

Why Traditional Feedback Loops Fail
If you’re running a SaaS today, chances are you’ve tried one (or all) of these:

Surveys → open rates are low, responses are shallow, and you only hear from the most vocal users.
Slack/Discord groups → valuable, but quickly devolve into support requests and noise.
Support tickets & emails → fragmented and hard to analyze at scale.
Spreadsheets/Notion docs → they start organized but soon become unmanageable dumping grounds.
The result? Feedback doesn’t actually drive growth. It becomes a backlog item rather than a strategy.

The Rise of Community-Driven Growth
2025 is not the age of one-way customer surveys. It’s the age of community-driven products.

Users don’t just want to report bugs or request features. They want to shape the roadmap, have their voices heard, and see the product evolve with them.

Companies that harness this win big. Look at how Notion, Linear, or Figma built loyal user bases: their communities were their best growth engines.

But here’s the catch: the more community you build, the harder it becomes to organize the flood of feedback.

Where AI Changes the Game
This is where AI enters the picture. Unlike humans (who burn out scanning 200 comments), AI thrives on large volumes of unstructured data.

Here’s what becomes possible:

Clustering feedback automatically → group 1,000 comments into 5 clear themes.
Sentiment analysis → know at a glance what users love vs. what frustrates them.
Priority scoring → highlight feedback patterns that correlate with churn or feature adoption.
Dashboards that update in real time → instead of waiting for a quarterly review, you see insights instantly.
In other words, AI turns chaotic conversations into actionable growth signals.

Introducing Droon AI
At Droon, we’re building exactly this: an AI-powered feedback and community engine for SaaS founders.

Here’s how it works:

Capture feedback from everywhere (community threads, support tickets, chats, emails).
Process with AI → clustering, sentiment, prioritization.
Present insights in a founder-friendly dashboard that shows you what to act on today.
Instead of drowning in unorganized feedback, you get a clear growth map drawn from your users’ voices.

We built Droon because we felt the pain ourselves — as founders, we’ve been on the other side, juggling half-baked spreadsheets and guessing what users wanted most.

Why This Matters for SaaS in 2025
The SaaS market is brutally competitive. Users have endless alternatives, and switching costs are lower than ever.

The companies that survive won’t be the ones with the fanciest marketing or biggest funding rounds. They’ll be the ones that listen best, adapt fastest, and build alongside their communities.

That’s the future of SaaS feedback: not just collecting data, but transforming it into a growth engine.

A Call to Founders
If you’re building SaaS today, ask yourself:

Do I really understand what my users are telling me?
Is my feedback loop driving my roadmap, or is it just noise in Slack?
What would it look like if every user conversation automatically shaped my product strategy?
That’s the vision we’re chasing with Droon.

Droon AI is live — founders are already using it to turn feedback into growth. If you’re ready to fix your feedback loop, we’d love to have you onboard.

👉 Get started today at droonai.com

Let’s build smarter, community-driven SaaS together.—

Rishu, Founder of Droon AI.

I Built Web2Docx – A Simple API to Convert HTML to PDF, DOCX & Images

Rishu Kumar — Wed, 14 May 2025 12:41:59 +0000

Hey Dev.to folks 👋

I wanted to share something I recently launched — Web2Docx — a simple API that converts HTML (or any URL) into PDF, DOCX, and image files.

Why I Built This
I was working on a client project last year where I had to generate custom invoices, certificates, and a lot of user-facing documents. Every tool I tried felt like a headache — either too complex, too slow, or not flexible enough with styling.

Some options required setting up headless browsers, others involved Word macros or weird templating engines. I just wanted something fast and reliable — pass some HTML and get a nice, styled PDF or DOCX back.

So I decided to build it myself.

What Web2Docx Does
🛠️ It supports:

HTML to PDF

HTML to DOCX

HTML to Image (PNG/JPEG)

⚡ Key highlights:

Fast and clean output

Supports modern CSS (no inline styles needed)

No need to install anything

Works great with React, Next.js, Node, etc.

You just send a POST request with your HTML or URL — and you get a downloadable file.

What's Unique
It's not based on puppeteer or headless Chrome (so it's faster and lighter).

DOCX generation is fully CSS-supported — no janky formatting.

Built with devs in mind: clean SDK and clear docs.

Try It Out
I just launched it on Product Hunt today. If you want to support or try it out, here’s the link:

👉 https://www.producthunt.com/posts/web2docx

Would love your feedback — especially from other devs who’ve been frustrated with document generation tools.

Documentations: Web2docx Documentation

How to Integrate It (Quick Example 🚀)
You can get started in just a couple lines using our official SDK:

npm i @web2docx/web2docx-sdk

const { Web2DocxClient } = require("@web2docx/web2docx-sdk");

const client = new Web2DocxClient("YOUR_API_KEY");

const fs = require("fs");

async function htmlToPdfExample() {
  const html = "<h1>Hello World</h1>";
  const pdfBuffer = await client.htmlToPdf(html);

  fs.writeFileSync("output.pdf", pdfBuffer);
}

htmlToPdfExample();

Thanks for reading ❤️