DEV Community: Kiran Naragund

AI Can Generate Code Faster. The Bigger Challenge Is Reviewing It 😐

Kiran Naragund — Sat, 27 Jun 2026 18:46:30 +0000

Hello Devs 👋

AI coding assistants have changed the way many teams build software. Tasks like generating components, creating tests, writing boilerplate, or handling repetitive refactors can now happen in minutes instead of hours.

The productivity gain is real and that part is easy to notice.

What becomes interesting after using these tools for a while is that a different bottleneck starts appearing. Code generation becomes faster, but the review process often stays the same.

Teams can generate hundreds of lines of code within minutes, but someone still has to answer important questions:

Does this actually solve the requirement?
Are edge cases covered?
Will this introduce side effects?
Does it align with existing patterns?

The speed of writing code has changed. The need for confidence has not.

That is where I think the conversation around AI-assisted development is starting to shift.

The challenge is becoming less about generating code and more about making sure the generated code is actually safe to ship.

The Problem With Reviewing AI-Generated Code Like Regular Code

Imagine asking an AI coding assistant to implement coupon validation for premium users.

Add coupon validation for premium users and create tests

A few seconds later you get:

if(user.isPremium){
   applyCoupon();
}

Nothing immediately looks wrong. The code is clean, there are no syntax issues, tests may pass, and the implementation appears complete.

But pull request reviews usually go beyond reading diffs.

Reviewers start asking questions such as:

What happens if the coupon has expired?
Does this affect payment calculations?
Should audit logs be updated?
Are there services depending on this behavior?

This is where AI-generated code becomes interesting.

It can often be functionally correct while still missing important implementation details. Research around larger AI-generated projects has also shown that functional correctness does not necessarily translate into maintainable system design. Teams still encounter duplicated logic, complexity growth, weak exception handling, and architectural inconsistencies.

Eventually humans catch these issues.

The question becomes:

Can we catch them earlier?

A Different Workflow: Cursor Builds, Qodo Reviews

One thing I found interesting is thinking about AI code generation and AI review as two separate responsibilities.

Instead of treating generation and validation as the same problem, Qodo positions itself as a quality layer across the development workflow.

The process becomes something like:

Generate → Review → Push → Review Again → Ship

Rather than:

Generate → Push → Hope the PR catches everything

Step 1: Feed standards before code gets generated

AI assistants work from context. If they do not know your architecture patterns, naming conventions, or domain rules, they fall back to generic assumptions.

Qodo introduces a shared rule system(agent-skills) that can provide those standards before generation starts. The same rules used later in reviews can also guide code generation itself. That means expectations stay consistent throughout the workflow instead of changing between development and review.

Step 2: Review locally before code leaves the IDE

Most review feedback arrives after a pull request is opened.

By then developers have often switched context and mentally moved on from the implementation.

One thing Qodo does differently is shifting review earlier into development itself. Local changes can be reviewed directly inside the IDE before they ever reach a repository.

That means issues such as:

Missing tests
Duplicated logic
Potential bugs
Violations of team standards

can surface while the implementation is still fresh in your head. Qodo describes this as a shift-left review approach where quality checks happen before PR discussions even begin.

Step 3: Review pull requests with full context

Traditional PR reviews usually focus on changed lines.

The challenge is that code changes rarely live in isolation.

Qodo's review system attempts to include broader context such as repository history, related code, dependencies, and organizational standards when evaluating a pull request. Multiple review agents then focus on different concerns like duplicated logic, breaking changes, critical bugs, and rule enforcement.

That changes the type of feedback you receive.

Instead of:

Variable naming could improve

You may get something closer to:

This update changes payment behavior but related audit handling appears missing

The feedback becomes more focused on intent and impact rather than surface-level observations.

AI Review Is Not Replacing Human Review

I do not think AI review replaces engineers.

Human reviewers still understand business decisions, architecture trade-offs, and product context in ways AI systems currently struggle with.

Where AI review becomes useful is reducing repetitive work and helping teams focus attention where it matters.

It can surface missing pieces, highlight risks, and point out areas worth investigating.

The role feels less like replacing code review and more like adding another layer of verification.

Final Thoughts

AI has already changed how quickly code gets written.

The next challenge is making sure quality scales with that speed.

What stood out to me is that Qodo is not trying to become another code generator. The idea seems closer to becoming a quality layer that sits alongside development and review workflows.

Cursor builds.

Qodo reviews.

That separation actually feels natural.

Because as teams generate more code with AI, confidence in what gets shipped becomes just as important as speed.

Resources & Getting Started

If you want to explore the workflow further, here are a few useful resources from Qodo:

Get started with Qodo:
Qodo Platform

Documentation and setup guides:
Qodo Documentation

Thank You!!🙏

Thank you for reading this far. If you find this article useful, please like and share this article. Someone could find it useful too.💖

Connect with me on X, GitHub, LinkedIn

Kiran NaragundFollow

Tech Writer and Moderator @DEV ✦ Full-Stack Developer ✦ Mentor @Exercism ✦ Open-Source Contributor ✦ Email for Collabs :)

Best AI Code Review Tools for Catching Breaking Changes 🔥

Kiran Naragund — Mon, 22 Jun 2026 19:51:45 +0000

Hello Devs 👋

Most code review tools are good at finding syntax problems, style issues, and missing test cases. The harder problem is finding changes that look harmless in a pull request but later break another service, API consumer, or application.

A renamed field, a modified function signature, or a small schema change can easily pass review. The code itself still works, but the impact shows up after deployment.

This is where AI code review becomes more interesting. Instead of looking only at the current file, some tools can understand context and identify changes that might affect other parts of the system.

⚡ Quick Verdict

Qodo is the best AI code review tool for catching breaking changes and reviewing high impact pull requests. It can fit naturally into GitHub workflows, analyze pull requests with more repository context, and focus on changes that can affect downstream systems.

For teams dealing with shared APIs, AI generated code, or larger codebases with multiple dependencies, this becomes useful because the review is not only checking code quality. It is also asking whether the change can break something after deployment.

That becomes even more useful when using a focused Breaking Changes agent that reviews things like API contracts, function signatures, interface changes, and backward compatibility.

What actually counts as a breaking change?

Breaking changes usually happen when code changes affect consumers outside the current file or service.

Common examples include:

Function signature changes
Removed or renamed fields
API response updates
Database schema modifications
Shared library changes
Interface updates

For example:

Before:

{
   "name": "John",
   "email": "john@example.com"
}

After:

{
   "fullName": "John",
   "email": "john@example.com"
}

The change itself looks small and clean. During review, many developers would approve this without a second thought.

The issue starts when another service still expects the name field. The code passes review, deployments succeed, and then suddenly downstream systems start failing.

Traditional review tools often miss this because there is no syntax problem. The problem is the impact of the change.

1. Qodo

Qodo becomes interesting because it can focus on pull request reasoning instead of leaving generic comments on every file.

Many AI review systems give suggestions around naming, formatting, or code cleanup. Those suggestions are useful, but they do not always help with production risks.

A focused Breaking Changes agent could instead ask questions like:

Did an API contract change?
Did a function signature change?
Did a shared interface change?
Can dependent services fail?
Is backward compatibility affected?

For example:

Before:

getUser(id)

After:

getUser(userId, includeMetadata = false)

The code still works and tests might still pass.

A Breaking Changes agent could still flag this and warn that consumers may still rely on the previous function signature. This creates more useful feedback because it focuses on downstream impact rather than only code style.

Best for:

Teams working with shared APIs, larger repositories, AI generated code, and pull requests where breaking downstream systems is a bigger concern.

2. GitHub Copilot

GitHub Copilot has already become part of many developer workflows and provides pull request summaries, code explanations, and development assistance.

It works well when teams want a broad coding assistant inside GitHub.

The limitation for this use case is that Copilot focuses more on overall developer productivity than specialized breaking change analysis.

Best for:

Teams looking for general AI assistance and coding productivity.

3. CodeRabbit

CodeRabbit automates pull request reviews and generates comments around changes.

The setup process is simple and the pull request summaries can help teams handling a large number of reviews.

Sometimes broader review systems generate many suggestions and comments. Over time developers can start ignoring reviews if too much low value feedback appears.

Best for:

Teams wanting automated pull request reviews with minimal setup.

4. Amazon CodeGuru Reviewer

Amazon CodeGuru Reviewer focuses more on code quality, performance, and security recommendations.

It can identify inefficient code patterns and suggest improvements across applications running in AWS environments.

Its focus is usually broader code quality analysis rather than contract awareness or downstream impact detection.

Best for:

AWS teams focused on performance and quality improvements.

5. SonarQube

SonarQube has been a common choice for static analysis and code quality checks for years. With newer AI related capabilities and integrations, teams are using it alongside AI workflows.

It performs well for identifying maintainability issues, security risks, and technical debt.

Breaking changes can still require additional context because static analysis alone may not understand the impact across multiple systems.

Best for:

Teams that already rely heavily on code quality gates and static analysis.

6. Snyk Code

Snyk Code mainly focuses on security analysis and code scanning.

For development teams where security and review happen together, it can become part of the pull request workflow.

While it is not designed specifically for breaking change detection, it helps catch risks that could eventually create larger issues in production.

Best for:

Security focused development teams.

Learning resources worth checking

If you want to go deeper into AI code review, Qodo also has a learning hub with practical articles around the topic. Some useful pieces include:

What is AI code review, which explains how AI reviews work and what they can actually detect
Reviewing AI generated code, which covers common patterns and mistakes developers often miss

These resources are useful if you want to understand not just the tools, but also the review process itself.

Final thoughts

When reviewing pull requests, the question is usually not whether AI can explain code better. The more useful question is whether the change can create problems after deployment.

A tool that creates twenty comments is not always more valuable than a tool that catches one issue that could break production.

For catching breaking changes, fewer and more relevant signals usually provide more value than large amounts of feedback.

Thank You!!🙏

Thank you for reading this far. If you find this article useful, please like and share this article. Someone could find it useful too.💖

Connect with me on X, GitHub, LinkedIn

Kiran NaragundFollow

Tech Writer and Moderator @DEV ✦ Full-Stack Developer ✦ Mentor @Exercism ✦ Open-Source Contributor ✦ Email for Collabs :)

🔥7 Tools Every AI Agent Developer Should Know in 2026

Kiran Naragund — Mon, 22 Jun 2026 06:38:55 +0000

Hello Devs👋

A year ago, most AI projects were glorified chatbots.

Today, we're building agents that browse websites, execute workflows, analyze data, monitor systems, interact with SaaS products, and collaborate with humans.

The challenge is no longer getting an LLM to answer questions. The challenge is giving AI agents reliable access to the real world.

After experimenting with dozens of frameworks and platforms, I've found that successful AI agents usually rely on a small set of tools that solve very specific problems:

Reasoning
Memory
Browser interaction
Workflow orchestration
Observability
Knowledge retrieval
Human collaboration

If you're building AI agents in 2026, these are seven tools worth knowing.

1. BrowserAct

Most AI agents fail when they leave the comfort of APIs and enter the browser.

Modern websites are full of:

Dynamic content
Login flows
CAPTCHA challenges
Anti-bot systems
Multi-step workflows

This is where BrowserAct becomes interesting.

BrowserAct is a browser automation CLI built for AI agents. It gives agents real browser control, anti-detection browser environments, human handoff when automation gets stuck, parallel sessions that do not interfere with each other, and independent browser identities for multi-account workflows.

Instead of simply opening pages and clicking buttons, it helps agents operate inside real-world browser environments while supporting:

Anti-detection browser profiles
Session management
Human handoff
Parallel browser tasks
Multi-account isolation
Reusable browser skills

I tested a simple BrowserAct workflow locally first.

Installing BrowserAct:

uv tool install browser-act-cli --python 3.12

To run my local browser, I listed the available browser profiles.

browser-act browser list-profiles

I then created a browser using my existing Chrome profile.

Now, Im going to extract the content from the website example.com

browser-act stealth-extract https://example.com --content-type markdown

Using BrowserAct with an AI Agent

I'm using Codex as the agent runtime for this experiment.

We can instruct the agent to use browser-act whenever browser interaction is required, such as opening pages, clicking buttons, handling login flows, or extracting structured data.

Here is my Agent prompt.

Set up BrowserAct for me. Read the BrowserAct skill first: [https://github.com/browser-act/skills/tree/main/browser-act](https://github.com/browser-act/skills/blob/main/browser-act/SKILL.md)/SKILL.md Install or update the browser-act skill, then verify it works. Use BrowserAct when I need an AI agent to browse, click, fill forms, handle login flows, solve CAPTCHAs, bypass bot detection, or extract structured data from websites. After setup, open this repository in my browser: https://github.com/browser-act/skills If I am logged in to GitHub, ask me whether you should star it for me as a quick demo that browser interaction works. Only click the star if I explicitly say yes.

Here is how the agent executed the workflow:

The agent successfully completed the task and starred the repository after receiving explicit confirmation.

While starring a repository is simple, the important part is that the agent successfully opened a real website, preserved browser state, interacted with UI elements, and completed an action inside an authenticated session.

Real Use Case: Competitor Monitoring Agent

Imagine building an agent that monitors competitor pricing across multiple ecommerce platforms.

A simple scraper often breaks because:

Pages require login
Content is dynamically rendered
Risk-control systems trigger
Browser fingerprints get flagged

With BrowserAct, the workflow becomes:

The key advantage is that browser identity, cookies, proxies, and session state remain isolated and reusable.

Real Use Case: Human Handoff

Every automation eventually encounters a step that requires a human.

Examples:

QR code login
SMS verification
Enterprise SSO approval
Security confirmation

Most automation tools simply fail at this point.

BrowserAct keeps the browser session alive and allows a human to complete the required action. Once verification is finished, the agent continues from the same session instead of restarting the workflow.

This sounds simple, but it solves one of the most common production bottlenecks in browser-based agents.

Testing Human Handoff with an AI Agent

To see how BrowserAct handles real interruptions, I tested the workflow using Codex as the AI agent runtime.

The goal was simple: let the agent handle the login process automatically, pause when human input becomes necessary, and then continue from the same browser session.

Here is the prompt I gave the agent:

Use BrowserAct for this workflow.

Open:
https://practice.expandtesting.com/otp-login

Actions:

1. Launch BrowserAct
2. Open the OTP login page
3. Fill the email field with:
   practice@expandtesting.com
4. Continue the login flow
5. If OTP verification is required:

   - Preserve browser state
   - Pause execution
   - Ask me for the OTP code
   - Wait for my response

6. After I provide the OTP:
   - Resume from the same session
   - Complete login
   - Confirm success

Do not restart the browser session if human input is needed.

Here is the Agent executions

Agent creating a browser session called expandtesting_otp_login for the execution
The agent entered the email automatically and paused at the OTP step while preserving the browser session.
After I provided the OTP, the agent resumed execution and completed authentication successfully.

What stood out here was not the OTP itself.

The interesting part was that the browser session remained active throughout the interruption. The workflow continued from the existing state instead of restarting the login process from the beginning.

Real Use Case: Multi-Agent Operations

Suppose you're running:

Customer support monitoring
Order review
Feedback analysis
Dashboard reporting

Instead of forcing everything into one browser session, BrowserAct allows each task to run independently while maintaining the required account state.

To understand how BrowserAct handles parallel workflows, I created multiple independent browser sessions locally.

Start separate browser sessions:

browser-act --session reviews browser open chrome_local_102863481715294440 https://reddit.com

browser-act --session ops browser open chrome_local_102863481715294440 https://status.openai.com

browser-act --session dev-community browser open chrome_local_102863481715294440 https://dev.to

Checking active browser sessions:

browser-act session list

Output:

The active session list showed that each workflow was isolated even though the browser profile remained shared.

This separation matters for long-running AI systems because browser state, cookies, and task execution stay independent and avoid cross-workflow interference.

For teams building agents that interact heavily with web applications, BrowserAct fills a gap that traditional browser automation tools were never designed to solve.

GitHub Repo:
https://github.com/browser-act/skills

2. LangGraph by LangChain

Reasoning alone is rarely enough for production agents.

As agents become more capable, you quickly run into problems like:

Multi-step workflows
Long-running tasks
Human approvals
State persistence
Multi-agent coordination

This is where LangGraph becomes useful.

LangGraph is designed specifically for building stateful AI agents that operate through graph-based workflows rather than simple request-response loops.

Instead of forcing everything into a single prompt, it allows developers to define controlled execution paths while still preserving agent flexibility.

Key capabilities:

Stateful workflows
Human-in-the-loop checkpoints
Durable execution
Multi-agent coordination
Retry and recovery handling
Streaming execution

Real Use Case: Customer Support Agent

Imagine a support agent handling enterprise tickets:

Read ticket details
Retrieve account information
Check documentation
Escalate complex issues
Request human approval when needed
Return a final response

Without orchestration, these workflows become messy very quickly.

LangGraph helps structure the decision flow while preserving memory and state.

Repository / Docs:

https://docs.langchain.com/oss/python/langgraph/overview

3. Mem0 by Mem0

Most agents have terrible memory.

They either:

Forget previous interactions
Stuff everything into context windows
Waste tokens repeatedly
Lose long-term user preferences

Mem0 solves this problem by acting as a persistent memory layer for AI agents.

Rather than replaying full conversations every time, it extracts useful information, stores it, and retrieves only what matters.

Key capabilities:

Persistent long-term memory
Automatic memory extraction
Memory compression
Cross-session recall
User preference tracking
Reduced token usage

Real Use Case: AI Personal Assistant

Imagine an assistant helping a user over several months.

Instead of repeatedly asking:

"What programming language do you use?"
"What projects are you working on?"
"What are your preferences?"

The agent remembers previous interactions and becomes more useful over time.

This makes interactions feel less like chatting with a stateless model and more like working with an actual assistant.

4. n8n

Building an AI agent is one thing.

Connecting it to the rest of your stack is a completely different challenge.

Agents rarely operate in isolation. They usually need to:

Trigger workflows
Update databases
Send emails
Connect with SaaS products
Call APIs
Execute scheduled tasks

This is where n8n becomes useful.

n8n is a workflow automation platform that helps AI agents interact with external systems through visual workflows and programmable logic.

Instead of writing custom integrations for every service, developers can connect agents to hundreds of tools while keeping workflows manageable.

Key capabilities:

Visual workflow builder
AI agent integrations
Self-hosted deployment
API connectivity
Scheduled workflows
Large integration ecosystem

Real Use Case: Lead Qualification Agent

Imagine an AI sales agent processing incoming leads:

Read lead information
Analyze qualification criteria
Update CRM records
Send personalized emails
Create support tickets
Notify sales teams

Without workflow orchestration, every integration requires additional code and maintenance.

n8n helps coordinate these actions while keeping the workflow transparent and easy to modify.

Link / Docs:

https://n8n.io/

5. Langfuse

AI agents become difficult to debug once they move into production.

When something goes wrong, questions appear quickly:

Why did the agent fail?
Which prompt caused the issue?
Which tool produced incorrect output?
Why did token usage suddenly increase?
Why did response quality drop?

This is where Langfuse becomes useful.

Langfuse is an observability platform designed for LLM applications and AI agents.

Instead of guessing what happened during execution, developers can inspect traces, prompts, model outputs, evaluations, and performance metrics.

Key capabilities:

Request tracing
Prompt debugging
Agent evaluation
Cost monitoring
Performance analytics
Session replay

Real Use Case: Production Agent Debugging

Imagine a customer support agent that suddenly starts returning poor responses.

A typical debugging workflow might look like:

Open execution traces
Inspect prompts
Review tool outputs
Analyze model decisions
Compare successful runs
Identify failure patterns

Without observability, debugging often becomes trial and error.

Langfuse helps developers understand what actually happened during execution.

Link / Docs:

https://langfuse.com

6. Qdrant

Many AI agents become significantly more useful when they can access external knowledge.

The challenge is that agents often need to work with:

Documentation
Internal knowledge bases
PDFs
Support tickets
Research data
Large collections of text

This is where Qdrant becomes useful.

Qdrant is a vector database designed for semantic search and retrieval workflows.

Instead of relying only on the model's built-in knowledge, developers can store embeddings and retrieve relevant information dynamically.

Key capabilities:

Vector search
Hybrid search
Metadata filtering
Scalable retrieval
Fast indexing
Production deployment support

Real Use Case: Internal Knowledge Assistant

Imagine building an AI assistant for a company.

The workflow could look like:

User asks a question
Generate embeddings
Search relevant documents
Retrieve matching information
Add context to the prompt
Generate a final answer

Without retrieval systems, the model depends only on what it already knows.

Qdrant helps agents access updated information and organization-specific knowledge.

Link / Docs:

https://qdrant.tech

7. HumanLayer

No matter how capable AI agents become, some decisions still require human involvement.

Examples include:

Financial approvals
Sensitive actions
Escalations
Security checks
Compliance reviews
Critical business decisions

This is where HumanLayer becomes useful.

HumanLayer is designed to add human approval and collaboration workflows into AI agents.

Instead of allowing agents to operate without oversight, developers can introduce checkpoints where humans review and approve actions before execution continues.

Key capabilities:

Human approval workflows
Slack integration
Escalation handling
Human checkpoints
Agent collaboration
Action gating

Real Use Case: Financial Approval Agent

Imagine an AI agent responsible for preparing payment requests:

Gather payment information
Validate transaction details
Generate recommendations
Send approval request
Wait for human confirmation
Execute approved actions

Without human collaboration layers, agents may perform actions that require oversight.

HumanLayer helps agents safely involve people when decisions become sensitive.

Link / Docs:

https://humanlayer.dev

Thank You!!🙏

Thank you for reading this far. If you find this article useful, please like and share this article. Someone could find it useful too.💖

Connect with me on X, GitHub, LinkedIn

Kiran NaragundFollow

Tech Writer and Moderator @DEV ✦ Full-Stack Developer ✦ Mentor @Exercism ✦ Open-Source Contributor ✦ Email for Collabs :)

Wiring AI Code Review into a Bitbucket + Jira Workflow

Kiran Naragund — Sun, 21 Jun 2026 19:02:11 +0000

Hello Devs 👋

If your team uses Bitbucket + Jira, your workflow probably looks something like this:

Pick a Jira ticket
Create a branch
Push code
Open a pull request
Get reviews
Merge and close the ticket

Pretty straightforward.

But as projects start growing and more developers join the team, things slowly become messy.

You start seeing situations like:

PRs with very little context
Requirements getting missed during implementation
The same review comments appearing repeatedly
Tickets marked as "done" while edge cases are still missing

Most discussions around AI code review focus heavily on GitHub workflows.

But many teams still work inside Bitbucket + Jira every day.

So I wanted to understand something:

Where does AI code review actually fit into this workflow?

Not just PR summaries. Not just generated comments..

Can it actually help developers during day-to-day work?

Let's get into it 🚀

Why Bitbucket + Jira Workflows Feel Different

Bitbucket and Jira already integrate really well.

You can:

Link branches directly to Jira tickets
Connect pull requests to issues
Track development progress automatically
Trigger CI/CD workflows

The problem usually is not integration.

The harder part is making sure implementation actually matches what the ticket intended.

Review discussions often become:

Did we update all affected services?
Does this fully match the Jira requirement?
Are tests missing?
Could this change affect something else?

Human reviewers catch a lot of this. But not always.

That's where AI review starts becoming interesting. Not as a replacement for reviews. More like an additional validation layer.

A Simple Bitbucket + Jira Workflow

Let’s take a basic example.

Step 1: Create a Jira ticket

Example:

PAY-142

"Add coupon validation for premium users"

Step 2: Create a linked branch

Something like:

feature/PAY-142-coupon-validation

Bitbucket automatically links the branch with Jira.

Step 3: Implement the change

You add something like:

if(user.isPremium){
   applyCoupon();
}

Looks fine.

PR opens successfully.

Tests pass.

Everything seems okay.

Step 4: Review the PR

Normally reviewers look at:

Code quality
Naming
Logic
Tests

AI reviewers can add another layer:

Did related files also need updates?
Are edge cases missing?
Does the implementation fully match the ticket?
Could this affect shared services?

Instead of replacing reviews, it helps fill small gaps.

Where I Found Qodo Interesting

While exploring AI review tools for this workflow, one thing I noticed with Qodo was that it tries to review more than just the changed lines inside a pull request.

Instead of focusing only on the PR diff, it attempts to understand:

Related files
Existing code patterns
Dependencies
Previous review context

For example:

Imagine the Jira ticket says:

Add audit logging for payment updates

Implementation:

updatePayment();

The code works.

Tests pass.

PR gets approved.

Everything looks fine.

Except logging was never added.

Traditional checks may not catch that.

A reviewer might miss it too.

In larger projects, where a single Jira ticket touches multiple files or services, having another layer looking for missing pieces can be useful.

I liked this because it felt less like:

"Here's a random AI suggestion"

and more like:

"Something related to this change might be missing"

That context becomes more useful as projects grow.

SonarQube vs AI Review in This Workflow

SonarQube still has an important role.

It helps with:

✅ Security checks
✅ Code smells
✅ Quality gates
✅ Coverage rules

But SonarQube mainly answers:

Is something technically wrong?
AI review often tries to answer:
Does this implementation make sense in context?

Both solve different problems.

📚 Want to Read More?

If you want to learn more about AI-assisted reviews and workflows, Qodo has a learning hub with some useful resources.

A few interesting ones:

What is AI Code Review
Good starting point if you want to understand how AI review works and what it tries to catch.
Reviewing AI Generated Code
Covers common mistakes and patterns teams see when reviewing AI-written code.
AI Code Review Tools Comparison
Useful if you want to compare approaches and understand where different tools fit.

🏁 Final Thoughts

AI code review is not replacing Jira workflows or human reviewers.

It adds another layer between:

Ticket → Code → Pull Request

For Bitbucket + Jira teams, that can help reduce:

Missing requirements
Repeated review comments
Small issues that become larger problems later

Most discussions online focus on GitHub.

But for teams already using Bitbucket and Jira every day, there is still a lot of value in adding AI review to the workflow.

👨‍💻 TL;DR

✅ Jira tracks requirements
✅ Bitbucket manages code changes
✅ AI review adds another validation layer
✅ Useful when PRs affect multiple files or services

As always, tools help, but good reviews still need humans.

Thank You!!🙏

Thank you for reading this far. If you find this article useful, please like and share this article. Someone could find it useful too.💖

Connect with me on X, GitHub, LinkedIn

Kiran NaragundFollow

Tech Writer and Moderator @DEV ✦ Full-Stack Developer ✦ Mentor @Exercism ✦ Open-Source Contributor ✦ Email for Collabs :)

From MVP to Production: Tools That Grow With Your SaaS 🚀

Kiran Naragund — Mon, 16 Mar 2026 03:20:09 +0000

Hello Devs 👋

Building a SaaS product is thrilling. But moving from your first MVP to a reliable production service takes more than code. You need scalable infrastructure for things like auth, billing, emails, uploads, observability, and execution intelligence. Building all of this from scratch slows you down and introduces risk.

That’s why many SaaS teams use proven tools and SDKs that solve real infrastructure problems so they can focus on the core product.

In this article you’ll get for each tool:

A clear description of what it does
Key features
Why it’s useful for SaaS
A simple getting-started guide
Links to official docs and websites

Let’s level up your SaaS stack 👇

What’s an SDK?

A software development kit (SDK) is a bundled set of tools that helps you integrate functionality or services into your application without building them from scratch.

SDKs often include:

Prewritten code libraries
APIs and interface definitions
Documentation and examples
Debugging or testing helpers

Using SDKs helps you:

Save time
Avoid reinventing the wheel
Reduce bugs
Build consistently across environments

Whether you need authentication, payments, emails, or production intelligence, well-chosen SDKs drastically speed up development.

Hud: Runtime Production Intelligence That Scales With You

Hud is a runtime code sensor that captures real production execution behavior and brings that context where engineers actually work in their IDEs and code review workflows. It continuously collects function-level execution data, detects issues like regressions or errors, surfaces root causes, and powers production-aware development with or without AI assists.

Unlike typical SDKs that provide discrete functions (like auth or payments), Hud is an intelligence layer. It does not change your business logic. Instead, it observes how that logic behaves under production traffic and delivers real execution insights back into your development loop.

Why It Matters

Most SaaS teams face a gap between:

What code looks like in source
How it actually runs under real customer load

This gap grows as you scale and adopt AI-assisted coding tools. Code suggestions and refactors that look valid in staging may fail in production because they lack real execution context.

Hud fills this gap by:

Giving function behavior signals from production
Detecting regressions or errors automatically
Pinpointing exact root causes
Feeding runtime context into supported IDEs
Enabling safer, production-aware AI coding workflows (MCP server)

In short, Hud helps you move from reactive debugging to proactive production confidence.

Key Features

Function-Level Execution Data: Hud captures how each function behaves in production: invocation counts, durations, error signals, and behavioral trends.
IDE Integration: Runtime summaries appear inside supported editors like VS Code and JetBrains. You get real behavior context without leaving your code.
Automated Issue Detection: Hud flags behavioral changes after deploys, new errors, and performance regressions with root cause context.
Production-Aware AI Coding: Hud’s MCP server streams production signals into AI assistants like Copilot or Cursor so generated suggestions align with how your code runs.
Minimal Overhead & Zero Config: It installs fast and runs safely in production without heavy configuration.

Why SaaS Teams Use It

Hud is not just another monitoring tool. It becomes valuable when:

Your app has real production traffic
Issues only show up after deploy
You use AI-assisted coding tools
You want deeper insight than logs or traces can provide

Beginner teams focused on MVPs usually do not need this yet. But once you have real users and production complexity, Hud helps teams catch issues early, fix them quickly, and build with confidence.

How to Get Started

Here is a simple guide to set up Hud in a Node.js app.

1. Create a Hud Account

First, sign up at hud.io and create your workspace. After signup you’ll get API keys for your project.

👉 Visit: https://hud.io

2. Install the Hud SDK

In your project directory, install the Hud package:

npm install hud-sdk

This installs the lightweight sensor that captures runtime behavior.

3. Initialize Hud Early in Your App

Hud works best when it starts before your application logic. So import and initialize it early in your main file.

Create a file named hud-init.js:

const hud = require("hud-sdk/setup");

hud.register({ includeModules: [] });

hud.initSession(process.env.HUD_API_KEY, "my-service");

Then, change your start script so this file loads first:

node --require ./hud-init.js index.js

Or import it at the top of your entry file:

import "./hud-init.js";
// ...rest of your app

4. Open Your IDE Extension

Install the Hud extension in your IDE (VS Code, JetBrains, or Cursor). This lets you see real production behavior right next to your code.

VS Code: Install from here
JetBrains IDEs: Install from here

Now you’ll see runtime summaries and signals directly in your editor.

5. Deploy and Watch Production

Once Hud is running in production, it starts collecting and sending runtime data automatically. You can view function performance, errors, and trends in the Hud dashboard or directly in your IDE.

Watch this quick demo video for better understanding 👇

Official Links

Documentation: https://docs.hud.io/docs/welcome
Website: https://hud.io
Install & Setup Guide: https://docs.hud.io/docs/installation-guide

Clerk: Authentication Without Building It Yourself

Clerk helps you handle authentication and user management without building everything from scratch. It takes care of users, sessions, and tokens, so your backend can trust who is making a request.

Instead of writing your own auth logic, you can use Clerk to verify users securely on the backend and protect your APIs.

Key Features

Secure user authentication
Session and token management
Easy backend verification
Works well with Node.js APIs
Dashboard to manage users

Why It’s Useful for SaaS

Every SaaS backend needs to know:

Who the user is
Whether the request is authenticated
Whether the session is valid

Doing this yourself is time-consuming and risky.

Clerk helps you:

Secure your backend APIs quickly
Avoid common auth mistakes
Scale user management as your SaaS grows
Spend less time on security setup

How to Get Started (Backend Setup – Node.js)

1. Create a Clerk Account

👉 Website: https://clerk.com

2. Install the Clerk Backend SDK

In your backend project, install Clerk:

npm install @clerk/clerk-sdk-node

3. Add Environment Variables

Add your Clerk secret key to your environment variables:

CLERK_SECRET_KEY=your_secret_key

4. Protect Backend Routes

Use Clerk middleware to protect your API routes.

import express from "express";
import { ClerkExpressRequireAuth } from "@clerk/clerk-sdk-node";

const app = express();

// Public route
app.get("/public", (req, res) => {
  res.json({ message: "Anyone can access this" });
});

// Protected route
app.get(
  "/api/dashboard",
  ClerkExpressRequireAuth(),
  (req, res) => {
    res.json({
      message: "Authenticated request",
      userId: req.auth.userId,
    });
  }
);

app.listen(3000, () => {
  console.log("Server running on port 3000");
});

Now, only authenticated users can access /api/dashboard.

5. Access User Information on the Backend

Once authenticated, you can safely access user data.

app.get(
  "/api/profile",
  ClerkExpressRequireAuth(),
  (req, res) => {
    res.json({
      userId: req.auth.userId,
      sessionId: req.auth.sessionId,
    });
  }
);

This makes it easy to link users to your database records.

Frontend Configuration (Quick Note)

Once your backend is protected, you’ll need to:

Add Clerk to your frontend (React, Next.js, etc.)
Send the authentication token with API requests

Clerk provides ready-made frontend SDKs and UI components to handle login and signup easily.

👉 Frontend setup docs: https://clerk.com/docs

Official Links

Documentation: https://clerk.com/docs

Website: https://clerk.com

Stripe: Payments and Subscriptions for Your SaaS

Stripe helps you handle payments and subscriptions without building complex billing logic yourself. It takes care of card payments, retries, invoices, and many edge cases that are hard to get right.

For a SaaS backend, Stripe is mainly used to:

Create subscriptions
Charge customers
Listen to payment events using webhooks

Key Features

One-time payments and subscriptions
Secure payment handling
Webhooks for billing events
Customer and invoice management
Widely used and well-documented

Why It’s Useful for SaaS

Almost every SaaS needs billing. Writing your own payment system is risky and slow.

Stripe helps you:

Start charging users quickly
Avoid payment and security issues
Handle upgrades, downgrades, and cancellations
Keep your backend in sync with payment status

How to Get Started (Backend Setup – Node.js)

Below is a simple backend setup using Node.js.

1. Create a Stripe Account

👉 Website: https://stripe.com

2. Install the Stripe SDK

Install Stripe in your backend project:

npm install stripe

3. Add Environment Variables

Add your Stripe secret key to your environment variables:

STRIPE_SECRET_KEY=your_secret_key

4. Initialize Stripe in Your Backend

Create a Stripe client that you can reuse in your app.

import Stripe from "stripe";

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY, {
  apiVersion: "2026-01-28",
});

export default stripe;

5. Create a Customer

When a user signs up for your SaaS, create a Stripe customer.

const customer = await stripe.customers.create({
  email: "user@email.com",
});

Store the customer.id in your database and link it to the user.

6. Create a Subscription

Use Stripe Checkout or create subscriptions directly from the backend.

const subscription = await stripe.subscriptions.create({
  customer: customer.id,
  items: [
    { price: "price_id_here" },
  ],
});

This starts billing the customer based on your pricing plan.

7. Handle Webhooks

Webhooks tell your backend when something changes, like:

Payment success
Payment failure
Subscription canceled

Create a webhook endpoint:

import express from "express";
import bodyParser from "body-parser";

const app = express();

app.post(
  "/webhook",
  bodyParser.raw({ type: "application/json" }),
  (req, res) => {
    const event = JSON.parse(req.body);

    if (event.type === "invoice.payment_succeeded") {
      console.log("Payment successful");
    }

    if (event.type === "customer.subscription.deleted") {
      console.log("Subscription canceled");
    }

    res.json({ received: true });
  }
);

NOTE: This is just a demo and getting started code, please refer the documentation and implement according to your application needs.

Use webhooks to:

Enable or disable features
Update subscription status in your database

Frontend Configuration (Quick Note)

On the frontend, you’ll usually:

Redirect users to Stripe Checkout
Or collect payment details using Stripe Elements

Stripe provides ready-made frontend tools so you don’t need to handle card data yourself.

👉 Frontend docs: https://stripe.com/docs/payments/checkout

Official Links

Backend Documentation: https://stripe.com/docs/api
Website: https://stripe.com/
Checkout Guide: https://stripe.com/docs/payments/checkout
Webhooks Guide: https://stripe.com/docs/webhooks

Resend: Send Transactional Emails Without the Complexity

Resend helps you send transactional emails from your backend easily and reliably.
This includes emails like:

Welcome emails
Login or magic link emails
Payment or subscription notifications

Instead of managing SMTP servers or complex email setup, Resend gives you a simple API that works well for SaaS products.

Key Features

Simple email-sending API
High email deliverability
Support for HTML and React email templates
Works well with Node.js backends
Minimal setup and clear logs

Why It’s Useful for SaaS

Every SaaS needs emails, but email infrastructure is often painful.

Resend helps you:

Send emails quickly without SMTP setup
Avoid common delivery issues
Keep email logic simple and clean
Focus on product logic instead of email servers

It’s especially useful for early-stage SaaS and MVPs.

How to Get Started (Backend Setup – Node.js)

Below is a simple backend setup using Node.js.

1. Create a Resend Account

👉 Website: https://resend.com

2. Install the Resend SDK

Install Resend in your backend project:

npm install resend

3. Add Environment Variables

Add your Resend API key to your environment variables:

RESEND_API_KEY=your_api_key

4. Send Your First Email

Create a Resend client and send an email from your backend.

import { Resend } from "resend";

const resend = new Resend(process.env.RESEND_API_KEY);

await resend.emails.send({
  from: "SaaS App <noreply@yourdomain.com>",
  to: ["user@email.com"],
  subject: "Welcome to our app",
  html: "<p>Thanks for signing up!</p>",
});

That’s it, your email is sent.

Frontend Configuration (Quick Note)

Resend is mostly used on the backend.
On the frontend, you usually just trigger backend APIs that send emails.

If you want nicer emails, Resend also supports React-based email templates.

👉 Email templates docs: https://resend.com/docs/dashboard/templates/introduction

Official Links

Documentation: https://resend.com/docs/introduction
Website: https://resend.com
Get Started: https://resend.com/docs/send-with-nodejs

UploadThing: Better file uploads

UploadThing helps you handle file uploads in your SaaS without building complex upload logic.
It takes care of file handling, storage, and validation so you don’t have to manage servers or storage APIs directly.

It works especially well with Next.js backends, but the idea stays the same: secure uploads with very little code.

Key Features

Simple and secure file uploads
File size and type validation
No custom storage setup needed
Works well with modern backend frameworks
Clean API and good developer experience

Why It’s Useful for SaaS

Many SaaS products need file uploads:

Profile pictures
Documents
Reports
Media files

Building uploads yourself takes time and is easy to get wrong.

UploadThing helps you:

Add uploads quickly
Avoid storage and security issues
Keep backend code simple
Focus on product features

How to Get Started (Backend Setup: Next.js / Node.js)

Below is a simple backend setup using Next.js API routes.

1. Create an UploadThing Account

👉 Website: https://uploadthing.com

2. Install the UploadThing SDK

Install UploadThing in your project:

npm install uploadthing

3. Add Environment Variables

Add your UploadThing API key to your environment variables:

UPLOADTHING_SECRET=your_secret_key
UPLOADTHING_APP_ID=your_app_id

4. Create an Upload Router (Backend)

Create a backend upload handler to define what files are allowed.

import { createUploadthing } from "uploadthing/next";

const f = createUploadthing();

export const uploadRouter = {
  fileUploader: f({
    image: { maxFileSize: "2MB" },
    pdf: { maxFileSize: "4MB" },
  }).onUploadComplete(({ file }) => {
    console.log("File uploaded:", file.url);
  }),
};

This controls:

Allowed file types
File size limits
What happens after upload

5. Expose the Upload Endpoint

Export your router so your app can use it.

import { createNextRouteHandler } from "uploadthing/next";
import { uploadRouter } from "./uploadRouter";

export const { GET, POST } =
  createNextRouteHandler({
    router: uploadRouter,
  });

Frontend Configuration (Quick Note)

On the frontend, you’ll:

Use UploadThing’s UI helpers
Connect them to your backend upload route

UploadThing provides ready-made components to make this easy.

👉 Frontend docs: https://docs.uploadthing.com

Official Links

Documentation: https://docs.uploadthing.com
Website: https://uploadthing.com

That's It.🙏

Building a SaaS that grows from MVP to production means choosing tools that scale with you. From authentication and billing to production intelligence and observability, these SDKs help you deliver value faster and more confidently.

If you find this guide useful, please like and share. Someone else building a SaaS might benefit too 💖

Connect with me on X, GitHub, LinkedIn

Kiran NaragundFollow

Tech Writer and Moderator @DEV ✦ Full-Stack Developer ✦ Mentor @Exercism ✦ Open-Source Contributor ✦ Email for Collabs :)

Enterprise AI Code Review in Real World Teams

Kiran Naragund — Thu, 26 Feb 2026 16:06:08 +0000

Hello Devs 👋

If you’ve only worked in small teams, adding AI code review feels almost trivial.

Install a tool.
Connect your repo.
Merge a PR and watch the comments roll in.

That is usually enough to get started.

Enterprise environments are a completely different story.

When you have:

300, 1,000, or even 10,000 developers contributing daily
Dozens or hundreds of repositories with different ownership models
Shared internal libraries that power half the company
Compliance requirements that are audited regularly
Multiple DevOps platforms coexisting across departments

AI review stops being a productivity experiment you try for a sprint.

It becomes an architectural decision that affects how the entire engineering organization works.

Let’s talk about what actually matters from a developer perspective.

What Changes in Enterprise Environments?

As developers, we usually think in very practical terms:

Does this comment actually help me improve the code?
Is this feedback technically accurate?
Is it going to slow me down while I am trying to ship?

At enterprise scale, the questions expand:

Will this behave consistently across all our repositories?
Is our proprietary code safe in the process?
Does this scale without flooding PRs with noise?
Can it enforce standards in a consistent and predictable way?

These are fundamentally different concerns compared to startup level tooling decisions. What works for 15 engineers does not automatically work for 1,500.

Multi Repo Reality

Most large companies are not running a single mono repo.

You will typically see:

A shared SDK repository used by multiple teams
Several microservices owned by different groups
Infrastructure as code repositories
Internal tooling and automation projects

Now imagine this scenario.

You change a shared interface in Repo A. That interface is consumed by 12 services spread across 8 other repositories.

A diff only review inside a single repo will not understand the blast radius. It cannot see how that change might ripple across dependent systems.

This is one of the biggest gaps I have noticed in many AI review tools.

They evaluate the pull request in isolation. Enterprises need tools that understand the system as a whole, not just the file that changed.

Platform Fragmentation Is Real

In large organizations, standardization is often aspirational rather than real. You will frequently find:

Azure DevOps in one department
Bitbucket in another
GitHub for open source initiatives
GitLab in specific regions or subsidiaries

If an AI review tool works well on only one platform, you are left with two uncomfortable options:

Fragment your tooling and accept inconsistent behavior
Force a company wide migration, which is rarely smooth or politically simple

From a developer perspective, consistency matters a lot. You do not want different review logic depending on which repository you happen to be working in that week.

Security and Deployment Constraints

This is where enterprise environments differ the most.

Many companies require:

SOC 2 compliance
On prem deployment options
Air gapped environments
Strict data retention and governance policies

If a tool requires sending proprietary code to an external service without clear controls, security teams will block it immediately.

As developers, we do not always see those conversations happening in the background. But they directly determine which tools we are even allowed to evaluate.

Comparing Tool Categories

Static Analysis Platforms

Example: SonarQube

What it does well:

Security scanning
Detecting code smells
Enforcing coverage thresholds
Providing compliance dashboards

Where it fits:

Baseline quality enforcement
Highly regulated environments

Where it does not help much:

Architectural reasoning
Cross repo impact awareness
Contextual AI style suggestions

It is reliable and predictable, but rule based.

Think of it as a guardrail. It keeps you within boundaries, but it does not actively review your design decisions.

Security Focused Platforms

Example: GitHub Advanced Security

Strong for:

Secret scanning
Dependency vulnerability detection
Improving overall security posture

Limitations:

Deeply centered around GitHub
Primarily focused on security, not full PR workflow
Does not reason about broader architecture

It protects you from known vulnerabilities.
It does not holistically improve pull request quality.

Lightweight AI PR Assistants

Example: CodeRabbit

Pros:

Very quick setup
Clear PR summaries
Useful for smaller, self contained repositories

Cons at scale:

Diff only analysis
Limited contextual awareness
Can become noisy in complex systems
Fewer governance controls

For a 20 developer team, this can be more than enough.

For a 1,000 developer organization with shared dependencies and layered architecture, it often falls short.

Context Aware Enterprise AI Review

Example: Qodo

This category aims to address:

Multi repo indexing
Dependency awareness
Cross repo impact detection
Custom rule enforcement
Flexible deployment models

From a developer standpoint, the real questions are simple:

Does it understand more than just my diff?
Are the suggestions precise and actionable?
Does it reduce back and forth during review?
Do engineers actually accept the suggestions?

If developers ignore the comments, the tool slowly fades into background noise. Adoption is earned, not mandated.

What Developers in Enterprises Actually Care About

When I talk to engineers in large organizations, their concerns are very pragmatic:

Is this going to slow my PR down?
Am I going to waste time dismissing false positives?
Does it understand our internal patterns and conventions?
Will it block my merge for the wrong reasons?

At enterprise scale, trust becomes everything.

A high acceptance rate matters more than impressive sounding AI explanations.

Precision beats volume.

A tool that leaves five accurate comments is more valuable than one that leaves fifty generic ones.

A Simple Enterprise Checklist

If I were evaluating AI code review in a large organization, here is what I would personally verify:

✅ Works consistently across Azure DevOps, Bitbucket, GitHub, and GitLab
✅ Understands multi repo dependencies and shared libraries
✅ Supports cloud, on prem, or air gapped deployment
✅ Demonstrates strong security posture and compliance certifications
✅ Allows custom rules aligned with team specific standards
✅ Shows real developer adoption, not forced usage metrics
✅ Scales beyond 100 developers without overwhelming PRs

If a tool fails two or three of these, it will likely struggle during enterprise rollout.

At the end of the day, AI code review in large organizations is not about adding more comments to pull requests. It is about building a system that developers trust, security teams approve, and architecture teams can rely on long term.

Thank You!!🙏

Thank you for reading this far. If you find this article useful, please like and share this article. Someone could find it useful too.💖

Connect with me on X, GitHub, LinkedIn

Kiran NaragundFollow

Tech Writer and Moderator @DEV ✦ Full-Stack Developer ✦ Mentor @Exercism ✦ Open-Source Contributor ✦ Email for Collabs :)

Can AI Code Review Actually Improve DORA Metrics?

Kiran Naragund — Thu, 19 Feb 2026 16:01:06 +0000

Hello Devs 👋

We talk a lot about AI speeding up coding.

You’ve probably seen numbers like:

"AI increases developer productivity by 25 to 35 percent."

Honestly that feels true, and multiple surveys and reports do show developers reporting significant boosts in productivity and time saved on routine tasks due to generative AI tooling. For example, large industry surveys show more than 80 percent of developers saying AI improved their individual productivity, and real-world telemetry showing task completion rising significantly with AI assistance.

Autocomplete feels better. Boilerplate goes faster. Refactoring can take fewer keystrokes.

But here’s something I’ve been thinking about lately:

If we are writing code faster, are we reviewing it faster too?

Because if review becomes the bottleneck, DORA metrics won’t improve. They might even get worse.

Let’s break this down in simple terms.

First, What Are DORA Metrics?

The DevOps Research and Assessment program defined four key engineering metrics:

Deployment Frequency
Lead Time for Changes
Change Failure Rate
Time to Restore Service

These metrics basically answer:

How often do you ship?
How long does it take to ship?
How often does it break?
How fast do you fix it?

If AI code review truly helps engineering performance, we should see positive movement across these.

Read more about DORA here 👉 https://getdx.com/blog/dora-metrics

The AI Code Review Paradox

Recent industry data suggests something surprising: teams with high AI adoption often see code review time increase sharply, even as code output rises. In Faros AI’s 2025 data, code review time grew by around ~91 percent as the volume and size of pull requests (PRs) increased.

That raises a question:

Why would review take longer when code is written faster?

Possibilities:

More PRs are being created
Larger diff sizes requiring deeper review
"AI-generated but needs cleanup" code is common
Reviewers double-check AI output carefully given trust concerns

So while coding accelerates, review capacity does not automatically scale to match.

That’s the paradox.

Let’s Connect AI Review to Each DORA Metric

Instead of looking at tools, let’s think logically.

1️⃣ Deployment Frequency

If reviews are faster, PRs merge faster.

If PRs merge faster, deployments can happen more often.

AI review can help by:

Giving instant feedback on PR creation
Catching obvious issues before a human reviewer steps in
Reducing back-and-forth cycles

But this only works if:

The feedback is accurate
Developers trust it

If it’s noisy, it slows things down instead.

2️⃣ Lead Time for Changes

Lead time = commit → production.

Where does most delay happen?

Usually:

Waiting for review
Fixing issues after review
CI failures

If AI review catches issues immediately inside the PR, it can reduce:

Rework cycles
Manual review load
Idle waiting time

Some organizations estimate meaningful time savings per PR when review insights trigger faster fixes, which compounds across a team.

3️⃣ Change Failure Rate

This measures how often deployments lead to failures.

Quality matters here.

Data from several sources shows that larger PRs and heavier reliance on AI-generated content can increase bug rates unless issues are caught before merge. In the Faros dataset, bug rates rose slightly even as output increased.

If review catches high-severity issues earlier:

Fewer production incidents
Fewer hotfixes
Less rollback stress

But false positives or poor insight quality don’t help. High-signal detection does.

4️⃣ Time to Restore Service

This one is indirect.

Better code quality means fewer incidents, and thus less firefighting.

AI alone doesn’t magically accelerate incident resolution, but it can prevent some incidents in the first place, easing the load on on-call teams.

Where Different Tools Fit

Now let’s look at tools categories:

Diff-First AI Review Tools

These look mainly at what changed in the PR.

Examples include lightweight PR assistants and AI summaries.

Pros:

Fast feedback
Easy setup
Helpful for small changes

Cons:

Limited context
Can miss architectural issues
Sometimes noisy

If developers start ignoring comments, DORA does not improve.

Static Analysis Tools

Rule-based analyzers like SonarQube catch security bugs, code smells, and other structural issues.

Pros:

Strong baseline quality checks
Good compliance signals

Cons:

Rule-based rather than contextual
Doesn’t inherently reduce review friction unless integrated deeply

Context-Aware AI Review

More advanced systems tools, like Qodo, try to analyze broader context beyond just the diff.

The idea is:

Understand surrounding files
Recognize patterns in your codebase
Provide more precise suggestions

If precision is high and developers trust it, this can meaningfully reduce review cycles.

If not, it becomes another notification stream to ignore.

What the Data Suggests

Here’s what current reports indicate:

High AI adoption can increase review time if processes don’t adapt, because PR volume and size grow faster than review capacity.
Developers widely report productivity improvements from AI while expressing mixed confidence in AI-generated code.
Survey data shows many developers remain cautious about trusting AI output and often verify it manually.

The key insight for me:

AI code generation alone does not improve DORA metrics.

AI review maturity does.

My Honest Take

If you are:

Writing more code because of AI
Creating more PRs
Increasing review load

Then you need to scale review alongside generation.

Otherwise:

Deployment frequency stalls
Lead time increases
Review fatigue grows

AI code review can improve DORA metrics.

But only if:

It integrates directly into your PR workflow
It provides high-signal feedback
Developers actually trust it

Without trust, metrics don’t move.

And that’s the part most discussions skip.

Thank You!!🙏

Thank you for reading this far. If you find this article useful, please like and share this article. Someone could find it useful too.💖

Connect with me on X, GitHub, LinkedIn

Kiran NaragundFollow

Tech Writer and Moderator @DEV ✦ Full-Stack Developer ✦ Mentor @Exercism ✦ Open-Source Contributor ✦ Email for Collabs :)

Setting Up AI Code Review in Bitbucket: A Practical Guide and Comparison⚖️

Kiran Naragund — Sun, 15 Feb 2026 06:53:25 +0000

Hello Devs 👋

If your team uses Bitbucket and you’re exploring AI code review tools, you might have noticed that many discussions online focus on GitHub. But Bitbucket is widely used too especially companies deep in the Atlassian ecosystem, and the experience with AI review tools varies a lot depending on platform support.

In this post, we’ll cover:

How tools integrate with Bitbucket
Setup complexity and time to value
Review quality you can expect
A comparison of Qodo, SonarQube, and CodeRabbit

Let’s get started 🚀

Bitbucket + AI Code Review: What You Should Know

Most Bitbucket teams use one of these:

Bitbucket Cloud
Bitbucket Data Center (self-hosted)
Bitbucket Pipelines for CI/CD

A good AI review tool should:

Support Bitbucket Cloud (minimum)
Ideally support Data Center too
Fit directly into your Pull Request workflow

There are usually 2 integration styles:

✅ Native Integration

You install the app from the marketplace, grant workspace access, and it comments directly on PRs using official APIs.

🔁 Webhook / API Setup

You generate tokens, connect via webhook, and the tool listens for PR events.

Both work, but the difference is how much setup and maintenance you deal with.

What I Look For in an AI Review Tool

When evaluating tools for Bitbucket teams, I focused on four things:

🔌 Integration Requirements

How easy is it to connect to Bitbucket Cloud or Data Center?

🧰 Setup Complexity

How long until you get value?
Is there heavy configuration?

🧠 Review Quality

Is the feedback useful?
Is it noisy?
Does it understand context?
Or does it only analyze diffs?

🔁 Ongoing Maintenance

Do I need to constantly tune rules and tokens?

🧩 Qodo: Context-Aware AI Reviews

Qodo supports Bitbucket integration and provides official setup documentation for both Cloud and Data Center.

Integration & Setup

Bitbucket Cloud

Sign in to Qodo.
Install the Bitbucket app.
Grant workspace access.
Select repositories.

That’s it.

Once connected, Qodo starts reviewing pull requests automatically.

Bitbucket Data Center

Upload plugin/app
Configure authentication tokens
Connect repositories

It works well if you’re self-hosted and have admin access.

Bitbucket Pipelines

You can trigger Qodo in CI using Bitbucket Pipelines.

Important:
PR comments come from the app integration, not directly from pipelines.

What You Get

Native PR comments
Multi-repo support
Team-level workflow integration

Review Quality

Qodo builds context from:

Your codebase
PR history
Related files

Not just the diff.

This usually means:

Higher signal
Less random noise
Better architectural feedback

Setup Complexity

Medium.

It’s mostly a one-time setup if you have workspace admin access.

🧩 SonarQube: Static Analysis Inside Bitbucket

SonarQube is a well-known static analysis tool. It integrates cleanly with Bitbucket.

But important thing is:

It’s not AI code review.
It’s static analysis.

Integration & Setup

Install SonarQube (Cloud or self-hosted).
Connect Bitbucket repositories.
Add analysis step in Bitbucket Pipelines.
Configure Quality Gates.

Once configured, it:

Decorates PRs with issues
Fails builds if quality gates fail
Tracks coverage and duplication

Review Quality

Excellent for:

Security scanning
Code smells
Technical debt
Coverage metrics

But it does not:

Reason about architecture
Explain design trade-offs
Provide AI-style improvement suggestions

Setup Complexity

Medium.

You need CI configuration. After that, it runs consistently.

🧩 CodeRabbit: Fast PR Feedback

CodeRabbit supports Bitbucket Cloud and focuses on quick PR reviews.

Integration & Setup

Create a Bitbucket service account.
Generate an API token.
Connect CodeRabbit to workspace.
Webhook is installed automatically.
It starts reviewing PRs right away.

What You Get

PR summaries
Inline comments
Basic customization options

Where It Struggles

CodeRabbit is mostly diff-first.

It focuses on what changed in the PR.
In simple projects, that works well.
In complex systems with interdependencies, it can:
Miss deeper architectural issues
Produce noisy suggestions

Setup Complexity

Low to Medium.

Token + webhook setup takes a few minutes.

Side-by-Side Comparision

Tool	Bitbucket Support	Setup Effort	Review Style	Best For
Qodo	Cloud & Data Center	Medium	Context-aware AI	Larger teams & complex codebases
SonarQube	Cloud & Server	Medium	Static analysis	Compliance & quality gates
CodeRabbit	Cloud	Low-Medium	Diff-first AI	Small teams & quick feedback

🛠 Quick Setup Summary

Qodo + Bitbucket

Install Bitbucket app
Grant workspace access
Select repos
Optional: Add Pipeline triggers
Open PR → Get AI feedback

SonarQube + Bitbucket

Deploy SonarQube
Connect repos
Add Pipeline step
Configure Quality Gates
PRs get decorated with analysis

CodeRabbit + Bitbucket

Create service account
Generate API token
Connect workspace
Webhook installs automatically
PRs get inline feedback

🏁 Final Thoughts

All the three tools bring value. But they solve different problems:

Qodo → deeper, context-aware AI review
SonarQube → strict quality & compliance checks
CodeRabbit → fast, lightweight PR feedback

There’s no single best tool.

The right choice depends on:

Team size
Codebase complexity
How deep you want reviews to go
Whether you need compliance gates

If you’re running serious workloads on Bitbucket, AI review absolutely helps but only if the tool fits your workflow.

Thank You!!🙏

Thank you for reading this far. If you find this article useful, please like and share this article. Someone could find it useful too.💖

Connect with me on X, GitHub, LinkedIn

Kiran NaragundFollow

Tech Writer and Moderator @DEV ✦ Full-Stack Developer ✦ Mentor @Exercism ✦ Open-Source Contributor ✦ Email for Collabs :)

Top Vibe Coding Platforms You Should Try This Year🫵

Kiran Naragund — Mon, 09 Feb 2026 03:32:22 +0000

Hello Devs 👋

Coding is changing fast. Today, you don’t always need to write everything from scratch. Many new platforms focus on speed, simplicity, and good vibes. This style is often called vibe coding where you focus more on ideas and building, and less on setup and stress.

These tools are great for:

Beginners who want to build real apps
Indie hackers and founders
Developers who want to move faster

In this article, I’ll share some of the best vibe coding platforms you should try this year.

Let’s start with Rocket.new 🚀

Rocket.new

Rocket is a powerful vibe coding platform that helps you turn your ideas into real apps fast. You describe your vision in simple English and Rocket uses AI to generate a full-stack app, including backend, frontend, database, and deployment setup. It also comes with useful app templates that speed up your workflow and lower the time to launch.

Rocket fits the modern vibe coding mindset: focus on ideas, not boilerplate code.

Key Features

Generate full-stack web & mobile apps from a text prompt.
Extensive app templates for landing pages, dashboards, mobile apps, and more.
AI-powered backend setup (database, auth, API).
Figma-to-code conversion support.
Deploy options: Netlify, custom domain, app store (via code export).
Live preview & iterative chat-style edits.

Integrations

Rocket connects with popular tools and services so your app can do real things:

Figma: import designs and convert them into code.
Supabase: database, storage, and user authentication out of the box.
Netlify: one-click web deployment.
Stripe: add payments easily.
GitHub: push code for version control and collaboration.
Google Analytics: track how users interact with your app.
AdSense: monetize your site or app with ads.
OpenAI, Anthropic, Gemini, and Perplexity: build AI features like chat, search, and content generation.
Twilio and Resend: send SMS and emails from your app.

Along with this, Rocket supports adding any REST/OpenAPI service by example, which makes integrations flexible.

Why People Like It

You can start building with just plain language, no deep coding knowledge needed.
It automates backend setup and deployment in one place.
Ready templates make launching prototypes much faster.
Integrations with databases, auth, payments, analytics, etc., give real-world power.
You can export real source code.

Best For

Startup founders prototyping MVPs
Designers turning Figma screens into apps
Indie hackers testing product ideas
Non-developers who want production-ready code
Builders who want AI + templates for fast delivery

Try Now

Emergent.sh

Emergent is an AI-powered vibe coding platform that helps you build full-stack web and mobile apps using natural language prompts. You simply tell the AI what you want, and it designs, codes, tests, and deploys your app from start to finish.

The platform handles frontend, backend, databases, integrations, and hosting, so you don’t need deep coding skills to launch real applications.

Key Features

Natural language prompts turn words into working apps without traditional coding.
Builds full-stack web & mobile apps, not just visuals or prototypes.
AI agents handle coding, testing, debugging, and deployment steps.
Instant website builder with layouts, forms, and workflows.
GitHub integration for code sync and version control.
Private project hosting and team collaboration features on paid plans.

Integrations

Emergent supports popular tools to power production apps:

GitHub for code and version control.
Data connections like Google Sheets or Airtable (on Standard plan).
Deployment services and APIs, including payment integrations such as Stripe on higher plans.

Why People Like It

You can create real applications from plain language descriptions.
Full-stack app building and deployment in one place removes a lot of traditional work.
Free tier lets you test the workflow before paying.
GitHub sync and private hosting are included on paid plans.

Best For

Solo builders and entrepreneurs trying to launch MVPs fast.
Non-technical creators wanting production apps without traditional coding.
Freelancers and small teams who need frontend + backend in one place.
Projects that benefit from AI-driven app generation and deployment.

Try Now

Lovable

Lovable is an AI-powered vibe coding platform that lets you build full web applications and websites simply by describing what you want in natural language. You don’t need deep coding skills, the platform generates real code, sets up backend services like database and authentication, and helps you shape your ideas into working software.

Lovable also includes visual editing and deployment tools that make it easier to move from idea to launch quickly.

Key Features

AI-driven generation of web apps and sites from natural language prompts.
Full-stack support: frontend, backend, database, and authentication included.
Visual editor for design and UX tweaks without code.
Integration with Supabase for database and user management.
GitHub sync and code export for version control and ownership.
Easy deployment and sharing options.

Integrations

Lovable works with tools that help make your apps functional and ready to grow:

Supabase for database, authentication, and storage.
GitHub for version control and collaboration.
Deployment services (like Vercel or built-in hosting) for going live quickly.

Why People Like It

You can turn plain language ideas into real apps fast.
It handles both frontend and backend so you don’t juggle many tools.
Simplifies building software without deep code knowledge.
Collaborative workspaces help teams build together.

Best For

Solo builders and entrepreneurs testing product ideas.
Designers and non-technical makers who want working apps.
Small teams that want fast prototypes and MVPs.
Developers who want both AI help and editable code.

Try Now

v0 (by Vercel)

v0 is an AI-powered UI and frontend development tool by Vercel. It helps you turn natural language prompts into clean, production-ready frontend code, especially for React and Next.js projects.

Instead of trying to generate an entire app end-to-end, v0 focuses on what it does best: design systems, UI components, layouts, and frontend logic. You describe what you want, and the v0 chat agent generates modern, editable code that fits perfectly into the Vercel ecosystem.

It’s ideal for developers and designers who want to move fast on UI without sacrificing code quality.

Key Features

Generate React & Next.js UI components from natural language prompts.
Produces clean, readable, and exportable frontend code.
Chat-based iteration to refine layouts, styles, and behavior.
Built with modern tools like Tailwind CSS and React best practices.
GitHub sync for easy code ownership and collaboration.
One-click deployment to Vercel.
Starter templates and examples for faster setup.

Integrations

v0 works seamlessly with the modern frontend stack:

GitHub: sync generated components to your repository.
Vercel: instant preview and production deployment.
Figma: supports design-to-code workflows for UI inspiration.
Works alongside backend services (databases, APIs, auth) that you connect separately.

Why People Like It

Excellent for quickly building polished UIs without starting from scratch.
The generated code is clean and easy to customize.
Fits naturally into existing React / Next.js projects.
Great balance between AI assistance and developer control.
Perfect companion to Vercel’s frontend-first workflow.
Best For
Frontend developers who want to speed up UI work.
Designers translating layouts into real React components.
Founders building landing pages, dashboards, or MVP frontends.
Teams using Next.js + Vercel who want fast iteration without low-code lock-in.

Try Now

Bolt.new

Bolt is a powerful AI-driven full-stack coding platform that lets you build, edit, and deploy complete web applications right in your browser without setting up any local environment. You describe what you want in simple natural language and the AI helps create real code, including frontend, backend, and integrations, all the way to deployment.

This makes it a great choice for developers and non-technical builders who want fast results and flexible code.

Key Features

Browser-based full-stack IDE with code editor, terminal, and live preview, no local installs needed.
AI-powered app builder generates frontend, backend logic, and database code from natural language prompts.
WebContainers technology runs Node.js and npm packages directly in the browser.
Real-time collaboration for teams on shared projects.
Framework flexibility with React, Next.js, Vue, Svelte, Astro and more.
Manual editing and debugging available alongside AI generation.
Instant deployment including hosting and custom domains.

Integrations

Bolt.new connects with essential tools to power your projects:

GitHub version control and repo sync.
Database and auth services like Supabase.
Stripe for payment and commerce features.
Figma design import and asset workflows.
Integrated hosting, SEO tools, and analytics on paid plans.

Why People Like It

No environment setup everything runs in your browser.
AI turns plain language ideas into working apps quickly.
You can swap between chat-style commands and manual coding.
Great for prototypes, MVPs, dashboards, and real products.

Best For

Solo developers launching prototypes and MVPs.
Indie hackers and founders testing product ideas.
Designers who want functional prototypes without deep coding.
Small teams needing real-time collaboration.

Try Now

That's It.🙏

Thank you for reading this far. If you find this article useful, please like and share this article. Someone could find it useful too.💖

Connect with me on X, GitHub, LinkedIn

Kiran NaragundFollow

Tech Writer and Moderator @DEV ✦ Full-Stack Developer ✦ Mentor @Exercism ✦ Open-Source Contributor ✦ Email for Collabs :)

AI Code Review Tools That Actually Work with Azure DevOps 🧪

Kiran Naragund — Sat, 07 Feb 2026 15:31:59 +0000

Hello Devs 👋

If you’re using Azure DevOps, you’ve probably noticed something:

A lot of AI code review tools are clearly built with GitHub-first workflows in mind. They may say they support Azure DevOps, but most of the documentation and community experiences focus on GitHub, and integration depth varies widely. Existing tooling often feels complex setups for multi-repo environments with strict governance requirements.

I’ve spent time evaluating common AI review tools from the perspective of large teams using Azure DevOps, what actually works day to day and what limitations you should be aware of.

Let’s get started 🚀

Why Azure DevOps Is a Bit Different

Azure DevOps is popular in enterprise settings because it supports:

Complex pipelines and build workflows
Fine-grained access control
Large multi-repo environments
On-prem and restricted deployment modes

Most AI review tools today are optimized for GitHub workflows and may claim broad support, but real usage patterns show differences in integration quality, especially around pull request automation and deeper context awareness.

In practice:

Many tools operate at “diff-only” scope
Few maintain persistent cross-repo understanding
Enterprise deployment options (on-prem/air-gapped) are rare

Those limitations are manageable for small teams but not for orgs with 100+ engineers and interconnected services.

What I Looked For in an AI Code Review Tool

Before comparing tools, here’s what actually matters in real Azure DevOps workflows:

✅ Native Azure DevOps integration

Automated PR comments and checks without brittle mirroring hacks.

✅ Context beyond the diff

Understanding cross-repo dependencies, ticket history, and architectural implications.

✅ Enterprise deployment options

Ability to run in restricted environments with strong security controls.

✅ Signal vs noise

Suggestions should be actionable, not repeatedly nitpicky.

Tools I Compared

🧩 What Is Qodo?

Qodo (formerly Codium) is one of the more context-aware review tools I’ve come across. It integrates with multiple platforms including GitHub, GitLab, Bitbucket, and Azure DevOps and aims to infuse deeper system context into automated reviews rather than just surface diffs.

What It Does Differently

🧠 Context-Aware Reviews

Unlike tools that only inspect the changed lines, Qodo indexes the repository, relationships between files, and historical patterns to provide more meaningful review feedback.

This makes it better suited to catch issues that are not obvious from the diff alone, such as:

Cross-file dependency risks
Incomplete scope based on ticketing history
Potential architectural regressions

🤖 Actionable Suggestions

Qodo’s review feedback isn’t just a list of possible problems, it tries to reason about why an issue matters and how it relates to the rest of the code. That tends to make suggestions easier to trust and adopt.

🔐 Deployment Options

Official tool documentation notes that Qodo supports integration across major version control systems, including Azure DevOps, making it fit into existing workflows in enterprise environments.

Where Qodo Fits Best

Large teams with multi-repo architectures
Teams that want more than line-by-line feedback
Workflows where automated context-aware checks add real value

🧩 What Is SonarQube?

SonarQube is a widely adopted static analysis and code quality platform that integrates with CI/CD systems including Azure DevOps. It provides detailed metrics on security, maintainability, test coverage, duplication, and compliance rules.

What It Does Well

Static quality checks
Security scanning based on rule sets
Integration into build pipelines and quality gates

Where It Is Limited

SonarQube focuses on rule-based detection, not AI-driven review suggestions. It flags issues but usually doesn’t provide reasoning or deep context on how a change affects a system’s architecture.

This doesn’t make it a bad tool, it’s just optimized for compliance and static analysis, not context-aware AI review.

🧩 GitHub Copilot Review

GitHub offers an AI review experience inside its platform that augments pull request feedback. It can summarize diffs and highlight potential issues within the PR’s visible files.

What It’s Good At

Inline code suggestions
Diff-level issue highlighting
Quick summaries inside GitHub PR UI

What It’s Not Designed For

System-wide or multi-repo reasoning, its context stays within the current repository and visible diff.

Policy governance, merge gating, or enterprise deployment options

Many teams using AI reviewers confirm that these tools often feel like enhanced linters, and that they don’t automatically scale to deeper architectural issues.

Copilot is best thought of as an assistant during development, not a dedicated AI reviewer.

🧩 CodeRabbit

CodeRabbit is an AI-assisted tool that automatically reviews pull requests and provides inline comments and summaries. It can be triggered automatically or manually within PRs.

What It Does Well

Fast PR summaries and inline comments
Easy to adopt for GitHub workflows

Where It Falls Short

Focuses on diffs rather than broader repo context, documented in CodeRabbit’s own feature scope.

Does not provide enterprise governance features like merge gating or compliance enforcement

Independent community feedback reflects that CodeRabbit can provide useful review help for small or medium teams, but struggles with deeper codebase or architectural context.

🔍 Quick Comparison

Tool	Focus	Strength	Limitation
Qodo	Context-aware reviews	System-wide insights, multi-repo	More setup than diff-only tools
SonarQube	Static analysis	Compliance, quality metrics	No AI review reasoning
Copilot Review	IDE-centric assistance	Inline suggestions	Limited to diff/visible files
CodeRabbit	PR summaries	Quick simple feedback	Lacks cross-repo reasoning

🏁 Final Thoughts

AI code review isn’t about replacing humans. It’s about catching what humans often miss in complex codebases.

A frequent pain point discussed by developers is how most reviewers behave like traditional linters, surface-level comments with limited project context.

For teams using Azure DevOps at an enterprise scale, the hard part is not generating suggestions, it’s understanding how those suggestions fit into a broader codebase, cross-repo patterns, and governance workflows.

Among the tools compared here, Qodo best addresses that gap with deeper context reasoning and integration across both PRs and enterprise workflows.

👨‍💻 TL;DR

Use Qodo when you need context-aware reviews that look beyond the diff.
Use SonarQube for static analysis and quality compliance.
Use GitHub Copilot Review for quick inline suggestions.
Use CodeRabbit for lightweight PR summaries.

💡 As always, the right tool depends on your project size, workflow, and quality standards. 🫡

Thank You!!🙏

Thank you for reading this far. If you find this article useful, please like and share this article. Someone could find it useful too.💖

Connect with me on X, GitHub, LinkedIn

Kiran NaragundFollow

Tech Writer and Moderator @DEV ✦ Full-Stack Developer ✦ Mentor @Exercism ✦ Open-Source Contributor ✦ Email for Collabs :)

🔥I Built an Awwwards-Style Portfolio Using Antigravity🌀

Kiran Naragund — Sun, 01 Feb 2026 10:53:04 +0000

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI

About Me

Hello! 👋

I’m Kiran Naragund, a full-stack developer, open-source contributor, and someone who genuinely enjoys building things on the web. I like turning ideas (even unclear or messy ones) into usable, meaningful software.

This portfolio represents my journey so far: my education, professional experience, open-source work, projects, and the many experiments I’ve done while learning and growing as a developer.

For a long time, I wanted to build an Awwwards-style portfolio. something cinematic, interactive, and animation-heavy but without using no-code tools like Framer. I wanted to do it using the tech I actually work with every day. 🙃

More than a resume, I wanted this portfolio to tell my story. My personality, my taste in design, my curiosity for animations, and my love for clean but expressive interfaces.

That’s how this minimal yet cinematic portfolio came to life. 😉

Portfolio

Visit here: https://kirannaragund.com

⚠️ Note: Please view this on a desktop or laptop for the best experience. Some animations and interactions are designed specifically for larger screens. I promise it’s worth it 🙏

How I Built It

I built this portfolio using modern and familiar tools:

React.js with Vite for fast development and performance.
Tailwind CSS for styling and theming.
GSAP and Framer Motion for animations and page transitions.
Lenis for smooth scrolling.
Chart.js for visualizing open-source activity.
A few shadcn/ui components.

Development Process

I didn’t start this project with a perfect design. I started with experiments.

I built the site section by section, testing animations, breaking layouts, removing things, and rebuilding again. This portfolio went through multiple redesigns before reaching its current state.

All the content (experience, education, certifications, skills, open-source data) is managed through structured data files, making the site easy to update and scale.

Design Decisions

I made a few bold and slightly risky 😅 decisions while building this.

🎨 Themes (10 of them!)

I don't wanted only light and Dark theme as many websites commonly offer this. So I decided to implement 10 different themes:

Light, Dark, Purple, Ocean, Forest, Sunset, Rose, Midnight, Coffee, and Mint.

Each theme updates colors, SVGs, and UI elements consistently. My personal favorites are White and Rose 😍. Let me know in the comments which one you liked.

🧩 SVGs instead of images

Because of the multiple themes, static images didn’t feel right.
So I switched to custom SVGs that adapt dynamically based on the active theme. This helped maintain visual consistency across all themes.

🫥 Hidden elements for better UX

Some animations looked amazing on large screens but felt overwhelming or broken on smaller ones (like SVG motion paths in the What I Do section).

Instead of forcing them everywhere, I selectively hide elements to keep the experience clean and enjoyable.

🔀 Route-based page transitions

Instead of traditional loaders, I added animated page transitions.
Whenever you move between pages, you’ll see fun, route-specific messages appear briefly in the center of the screen.

It’s a small detail, but it makes navigation feel playful and alive.😄

Open Source Section (Beyond the Green Graph)

Most developer portfolios show the default GitHub contribution graph. I didn’t want to do that.

Instead of just showing green squares, I wanted visitors to see my actual open-source work in a clear and useful way. So I built a dedicated Open Source section where people can easily explore:

Organizations I’ve contributed to
Pull requests I’ve opened
Issues I’ve worked on
Contribution activity over time

This makes my open-source work more transparent and easier to understand. Anyone visiting the site can quickly see what I contributed, where I contributed, and how active I am, without needing to jump around GitHub.

For me, this felt more meaningful than a static activity graph.

What Google AI Tools Did I Use?

Antigravity IDE 🫡

I used Antigravity IDE for most of the development.

While building the site, I kept updating a plan.md file where I wrote ideas, page structure, animation plans, and things I wanted to improve. This file changed many times as the project evolved.

I often switched between different AI models inside the IDE, sometimes for planning, sometimes for refactoring code, and sometimes just to explore better ways to structure components or animations.

Gemini Nano Banana 📸

I used Gemini Nano Banana to generate mockups for my projects sections.

These both tools made the process smoother and helped me iterate faster.

What I'm Most Proud Of

Honestly, building this portfolio feels like a dream come true for me.

There was a time when I only imagined creating something like this. Now it’s live, and people can actually experience it. This project pushed me far outside my comfort zone and forced me to try things I had never done before.

Some things I’m especially proud of:

Learning and using GSAP for complex SVG paths and timeline-based animations.
Creating a custom Google-style loader animation that introduces the site in a playful way.
Adding route-based page transition animations with different messages for each section.
Building a custom animated cursor for smoother interactions.
Creating a fully theme-aware design system with 10 different themes that work consistently across the site.
Showcasing my open-source contributions using real data and charts, instead of a basic GitHub graph.
Making the site interactive and cinematic, without overwhelming the user.

This portfolio taught me patience. I experimented a lot, broke things often, and learned how small details can completely change how a product feels.

It’s not perfect but it’s honest. It represents how I think, build, and learn. And that’s what makes it special to me. 🙃

Made with love, hate, and too many revisions because perfection doesn’t arrive gracefully, it’s dragged out through frustration, stubbornness, and late-night bargaining with my laptop.

Thanks for reading, and I’d love to hear your feedback! 🙌

Kiran NaragundFollow

Tech Writer and Moderator @DEV ✦ Full-Stack Developer ✦ Mentor @Exercism ✦ Open-Source Contributor ✦ Email for Collabs :)

Have you seen your DEV Wrapped 2025 yet? 🎁

Kiran Naragund — Thu, 18 Dec 2025 04:53:57 +0000

Kiran Naragund

Dec 15 '25

🎉 DEV Wrapped 2025 – See Your Year in Code!

#discuss #devwrapped #programming #showdev

174

1 min read