Forem: Jyoti Prajapati

Why I Built an AI "Agent" to Handle My PR Reviews (And You Should Too)

Jyoti Prajapati — Tue, 03 Mar 2026 11:24:57 +0000

The Hook
In 2024, we were impressed when AI could write a function. In 2025, we got used to "Copilots." But in 2026, the real power lies in Agentic Workflows.

I got tired of the "ping-pong" game of PR reviews—linting errors, missing tests, and architectural inconsistencies that a human shouldn't have to waste time pointing out. So, I stopped using AI as a chatbot and started using it as an Agent.

1. The Shift: Autocomplete vs. Agents
The biggest mistake devs make is treating an LLM like a search engine.

Autocomplete (Old): You write function, AI suggests the rest.
Agentic (2026): You give a goal ("Review this PR for security vulns and run the test suite"), and the Agent decides which tools to call, executes them, and reports back.

2. The "Agentic Loop" Workflow

My agent follows a 4-step loop:
1. Analyze: It reads the git diff.
2. Reason: It asks: "Do I need more context?" If yes, it calls a tool to read the README.md.
3. Execute: It runs the local test suite. If tests fail, it doesn't just tell me - it suggests the fix and re-runs the test.
4. Finalize: It posts a summary comment on GitHub with a "Ready for Human" badge.

3. The Secret Sauce: The System Prompt
To get high-quality reviews, you have to move past "Review this code." I use a persona-based prompt:

System Prompt: Senior PR Architect

Goal: Review the provided git diff for logical errors and security vulnerabilities.

Constraint: Do NOT comment on linting or formatting. Focus ONLY on logic and edge cases.

Output: If 'Safe', provide a 3-bullet summary. If 'Unsafe', provide the exact line number and a fix.

4. The Result: 40% Less "Nitpicking"
Since deploying this internally, my total review time dropped from 24 hours to under 2 hours. Banality is gone; we only discuss high-level architecture now.

Conclusion: Don't just code, Orchestrate.
The "10x Engineer" of 2026 isn't the one who writes code the fastest. It's the one who builds the best agents to manage the "grunt work" of the SDLC.

Are you worried about AI Agents having write-access to your repos, or is the productivity gain worth the risk? Let’s discuss below!

What you use?

Jyoti Prajapati — Thu, 12 Feb 2026 06:20:19 +0000

Bridging the Gap: Navigating RTSP vs. WebRTC in Cloud Video Pipelines

Jyoti Prajapati ・ Feb 11

#architecture #webrtc #kafka #devops

Bridging the Gap: Navigating RTSP vs. WebRTC in Cloud Video Pipelines

Jyoti Prajapati — Wed, 11 Feb 2026 14:04:30 +0000

In the world of cloud-based video streaming, not all "live" feeds are created equal. Depending on whether you're dealing with a legacy industrial sensor or a modern smart doorbell, the way video moves from the edge to the cloud varies wildly.

As we scale cloud surveillance and monitoring, understanding the nuances between RTSP and WebRTC— and how to normalize them - is the difference between a seamless user experience and a high-latency nightmare.

The Landscape: Camera Types and Their Native Tongues

Different hardware is built for different environments. While enterprise cameras still rely on established standards, consumer-grade IoT devices are pushing toward web-native protocols.

Camera Protocol Mapping

1. Standard/PTZ IP Camera
Typical Protocol: RTSP
Ingestion Strategy: Direct ingestion via RTSP into the pipeline

2. Video Doorbell
Typical Protocol: WebRTC
Ingestion Strategy: Normalize via MediaMTX for storage/HLS.

3. Mobile App Cameras
Typical Protocol: WebRTC
Ingestion Strategy: Push stream to gateway for normalization.

4. Thermal/AI Cameras
Typical Protocol: RTSP
Ingestion Strategy: Standard RTSP ingestion for heavy analytics.

The Showdown: RTSP vs. WebRTC

Choosing a protocol isn't just about what the camera supports; it’s about what your cloud architecture can handle.

RTSP: The Reliable Workhorse
RTSP (Real-Time Streaming Protocol) is the "old guard." It is a pull-based protocol, meaning your cloud server requests the stream from the camera.

Pros: Universal support, incredibly simple to record (just capture the RTP packets), and rock-solid for wired environments.

Cons: Struggles with firewalls (requires NAT traversal or VPNs) and has a "baked-in" latency of 1–2 seconds.

WebRTC: The Low-Latency Speedster

WebRTC (Web Real-Time Communication) was designed for the modern web. It is push-based and optimized for sub-second latency.

Pros: Ultra-low latency (<500 ms), built-in encryption, and handles fluctuating Wi-Fi speeds beautifully thanks to adaptive bitrate.

Cons: It’s "chatty." It doesn't have a simple URL you can just plug into a player. It requires a gateway (like MediaMTX) to convert it into a format suitable for long-term storage or HLS distribution.

Strategy: Building a Unified Cloud Pipeline

You shouldn't have to build two different clouds just because you have two different cameras. The goal is normalization.

Whether the video starts as an RTSP pull or a WebRTC push, it should end up in a unified format for your users and your AI.

Recommended Workflow

For RTSP Feeds: Pull the stream directly into your cloud ingestor. Convert to HLS for multi-device live viewing and store the raw packets for VOD (Video on Demand).
For WebRTC Feeds: Use a media server (like MediaMTX) as a gateway. This "normalizes" the WebRTC stream, transcoding or repackaging it into HLS or RTSP.
The Analytics Layer: Once normalized, feed the stream into your AI/ML pipeline for motion detection, object recognition, or thermal alerts.

Pro Tip: If you are building for smart home devices or mobile apps, start with WebRTC. The ability to pierce through home firewalls without complex port forwarding is a game-changer for user setup.

Conclusion
There is no "winner" in the RTSP vs. WebRTC debate—only the right tool for the job. RTSP remains the king of stable, wired surveillance, while WebRTC is the undisputed champion of interactive, low-latency smart devices. By using a normalization gateway in your pipeline, you can support both without doubling your engineering effort.

Comment below if You find this Interesting. In the Next I will show you can setup the MediaMTX for the RTSP and WebRTC Stream.

Weekend plans

Jyoti Prajapati — Fri, 06 Feb 2026 13:53:47 +0000

Monday Morning is a Trap. My 10-Minute “Sunday Reset” for a Frictionless Week ☕

Jyoti Prajapati ・ Feb 6

#productivity #tooling #webdev #career

Monday Morning is a Trap. My 10-Minute “Sunday Reset” for a Frictionless Week ☕

Jyoti Prajapati — Fri, 06 Feb 2026 13:52:31 +0000

It’s Friday. You’re likely staring at a messy IDE, a terminal with 12 dead tabs, and a brain that is 90% in "Weekend Mode."

The standard hustle-culture advice? "Start a weekend project! Build a SaaS! Grind LeetCode!"

My Senior-level advice? Don't. In 2026, the gap between a "Burnt Out" developer and a "High-Performer" isn't about how many hours they spend coding on Saturday.

It’s about how much cognitive friction they remove before Monday morning. I call this the Sunday Reset. It takes 10 minutes, and it saves me 10 hours of "Monday Fog."

Here are the 4 specific resets I do to make sure Monday morning feels like a downhill sprint.

1. The Agent Health-Check (Cursor + Roo Code) 🤖

By Friday, your AI Agent has probably "learned" a bunch of temporary hacks you used to fix bugs during the week. If you don't reset its context, it will keep suggesting those same hacks on Monday, even for new features.

The Reset: Clear your "Composer" or Chat history. Update your .cursorrules (or global instructions). If you discovered a specific architectural pattern that worked this week, hard-code it into your agent's instructions now.
The Payoff: On Monday, you aren't fighting your AI; you're working with an assistant that actually remembers your current "Best Practices."

Senior Tip: Treat your AI Agent like a Junior Dev. If you don't give it a clear brief after a weekend break, it will hallucinate.

2. The Latency Purge (Ghostty Terminal) 👻

We spend 8 hours a day in the CLI. If your terminal has even 20ms of input lag, you are draining your mental battery without realizing it.

The Reset: Kill all those "ghost" processes from Friday. I’ve switched entirely to Ghostty (the GPU-accelerated terminal) because it’s the only thing that keeps up with 2026-level workflows. Reset your tabs. Close your SSH sessions.
The Payoff: A fresh, snappy terminal. It sounds small, but "zero-latency" typing is the fastest way to get back into the Flow State after 48 hours away.

3. The "Local First" Fallback (Ollama + DeepSeek) 🏠

Monday mornings are notorious for "Service Outages." If your productivity depends entirely on a *cloud API *(OpenAI/Anthropic) and they go down, your morning is wasted.

The Reset: Ensure your local Ollama instance is running and has the latest weights for a lightweight, high-performance model (like Llama 3.3 or DeepSeek-V3).
The Payoff: If the internet is spotty or the cloud is lagging on Monday, you have a private, instant "Brain" on your local machine. No excuses.

4. The "One-Command" Environment (Nix / Devenv) ❄️

Nothing kills Monday momentum faster than: "Wait, why is my Node version wrong?" or "The database container won't start."

The Reset: Run devenv up or your Nix shell command once on Sunday evening. Just once. Make sure the environment mounts and the dependencies are cached.
The Payoff: When you cd into your project on Monday, you aren't a "System Administrator." You're a Developer.

The 10-Minute Challenge

This weekend, don't build a new app. Sharpen your tools instead.

Prune your AI instructions.
Purge your terminal processes.
Sync your local LLMs.
Test your dev environment.

Monday morning you won't be "booting up." You'll be executing.

What’s one "tiny friction" in your workflow that’s been bugging you all week? Let’s solve it in the comments. 👇

Blog #4 How the word "Bank" knows what it means: Self-Attention explained intuitively

Jyoti Prajapati — Tue, 27 Jan 2026 13:43:47 +0000

Welcome back to the Transformer Series!

In Blog #3, we gave our Transformer a sense of "Time" using Positional Encoding. It now knows the order of words. But even with order, words are still fundamentally lonely.

If I just say the word "Bank," what comes to mind?

A place to store your money? 🏦

The edge of a river? 🛶

As a human, you don't even think about this ambiguity. You instantly look at the surrounding words to decide:

"I went to the bank to deposit a check." (Money context) "I sat on the bank and watched the river flow." (Nature context)

Before Transformers, older models struggled with this. They often treated the word "Bank" the same way regardless of the sentence.

The Transformer solves this with Self-Attention. It’s the mechanism that allows the word "Bank" to "look around" at the other words in the sentence and update its own meaning based on who it is hanging out with.

The Context Crisis: Why we needed a revolution

In the early days of NLP, we had a "memory" problem.

Models like RNNs (Recurrent Neural Networks) and LSTMs were like readers who had a very short attention span. They read from left to right, one word at a time. By the time they reached the end of a long sentence, the "state" of the first few words had started to fade.

Imagine reading this:

"The cat, which was chased by the neighbor's massive, loud, and energetic dog that always escapes its yard, ran up the tree."

An RNN might struggle to remember that "ran" refers to the "cat" and not the "dog" because so much "noise" happened in between.

Self-Attention changed everything. It said: "Stop reading in order. Let every word look at every other word, all at once."

The Deep Dive: How the "Search Engine" Math Works
To make this happen, we don't just use one vector per word. We use three.
For every input word, we generate a Query (Q), a Key (K), and a Value (V).

These aren't magic; they are created by multiplying our input embedding by three weight matrices ($W^Q, W^K, W^V$) that the model learns during training.

1. The Query (Q): The "Ask"Think of this as the word's "Personal Interest Profile." The word "Bank" sends out a Query: "I am looking for anything related to finance or geography."

2. The Key (K): The "Label" Every word in the sentence has a Key. It’s like a metadata tag. The word "Deposit" has a Key that says: "I am a financial action.

3. The Score: The "Compatibility Test
We take the Query of "Bank" and the Key of "Deposit" and do a Dot Product.

If they are highly related, the number is huge.
If they are unrelated (like "Bank" and "The"), the number is near zero.

Score = Q.K^T

4. The Softmax: The "Attention Filter"
We take all those scores and pass them through a Softmax function. This turns the scores into probabilities that add up to 100%.

Deposit: 0.85
The: 0.02
Check: 0.13 This tells the model: "When processing 'Bank', spend 85% of your energy looking at 'Deposit'."

5. The Value (V): The "Payload"
Finally, we multiply our percentages by the Value vectors. The Value is the actual information the word carries. We sum them up, and BAM — we have a new, "Context-Aware" version of the word "Bank."

Below is one more example for Q, K, and V:

The "Scaling" Secret: Why we divide by sqrt(d_k) You’ll often see this in the official formula:

Attention (Q, K, V) = softmax((QK^T)\sqrt(d_k))V

Technical "Senior" Tip: Why the division?
As the dimensionality (d_k) of our vectors grows, the dot product QK^T can grow very large in magnitude. When these values are huge, the softmax function gets pushed into regions where the gradient is extremely small (the "vanishing gradient" problem). By scaling down by sqrt(d_k), we keep the math stable and ensure the model can actually learn.

The Code: A Raw Implementation
As a developer, you don't really understand it until you see the shapes. Here is how you would write this in PyTorch (without the abstractions):

import torch
import torch.nn.functional as F

def basic_self_attention(q, k, v):
    # q, k, v are of shape [batch_size, seq_len, d_k]
    d_k = q.size(-1)

    # 1. Compute scores (Matrix multiplication)
    # [batch, seq_len, seq_len]
    scores = torch.matmul(q, k.transpose(-2, -1)) 

    # 2. Scale
    scores = scores / torch.sqrt(torch.tensor(d_k, dtype=torch.float32))

    # 3. Apply Softmax to get weights
    weights = F.softmax(scores, dim=-1)

    # 4. Multiply by Values
    # [batch, seq_len, d_k]
    output = torch.matmul(weights, v)

    return output, weights

Why This Architecture Won

1. Total Parallelization: Unlike RNNs, which have to wait for word 1 to finish before starting word 2, Self-Attention calculates the entire sentence's relationships simultaneously. This is why we can train massive models like GPT-4 on thousands of GPUs.

2.Global Reach: A word at the very beginning of a 1,000-word document can "attend" to a word at the very end in a single calculation. No memory loss.

Summary
Self-Attention is the "Brain" of the Transformer. It's the mechanism that turns a sequence of isolated words into a cohesive, contextual map of meaning.

Queries ask the questions.
Keys provide the answers.
Values provide the content.

Next up in Blog #5: What's better than one "Attention" spotlight? Eight of them. We’re diving into Multi-Head Attention and why "splitting your focus" is the secret to high performance.

Happy Reading

Found this deep dive useful? Bookmark it for your next interview, and let me know in the comments: What was the specific 'aha' moment for you when learning about Q, K, and V?

[Boost]

Jyoti Prajapati — Mon, 26 Jan 2026 03:28:41 +0000

Transformer Series - Blog #1: Neural Network Fundamentals You Must Understand Before Transformers

Jyoti Prajapati ・ Jan 15

#tutorial #beginners #machinelearning

Transformers end to end series from Zero

Jyoti Prajapati — Mon, 26 Jan 2026 03:28:19 +0000

Transformer Series - Blog #1: Neural Network Fundamentals You Must Understand Before Transformers

Jyoti Prajapati ・ Jan 15

#tutorial #beginners #machinelearning

Great Savior for VS Code Devs

Jyoti Prajapati — Thu, 22 Jan 2026 12:22:15 +0000

5 VS Code Extensions I Can't Live Without in 2026 🚀

Jyoti Prajapati ・ Jan 22

#vscode #webdev #productivity #tooling

5 VS Code Extensions I Can't Live Without in 2026 🚀

Jyoti Prajapati — Thu, 22 Jan 2026 12:19:08 +0000

Let’s be honest.

We all have that one folder in our brain (and our VS Code sidebar) full of extensions we installed three years ago and completely forgot about.

But as a Senior Developer, I don't want more tools. I want better tools. I want extensions that stay out of my way until I need them, and then save me 30 minutes of debugging in 30 seconds.

In 2026, our workflows are faster and more AI-driven than ever. Here are the 5 VS Code extensions that have earned a permanent spot in my setup this year.

1. Error Lens 🔍

If you install only one extension from this list, make it this one.

By default, VS Code puts a tiny red squiggly line under your errors. You have to hover over it, wait for the popup, and read the tiny text. Error Lens takes that error message and prints it right next to the line of code in your editor.

Why I love it: It makes bugs impossible to ignore. It forces you to fix syntax errors immediately, rather than letting them pile up until compile time.

Pro Tip: It also works great with linters (ESLint), so you see "Missing semicolon" instantly.

2. GitLens — Git Supercharged ⚡

Okay, this is a classic, but in 2026, it is non-negotiable for professional work.

GitLens gives you "X-Ray vision" into your code. The killer feature? Current Line Blame. As soon as you click a line of code, it shows you:

Who wrote it.
When they wrote it.
The commit message associated with it.

Why I love it: It stops me from asking "Who wrote this garbage?" only to realize... it was me, 6 months ago. 😅

3. Pretty TypeScript Errors 💅

If you work with TypeScript, you know the pain. You make a mistake, and VS Code throws a generic error that looks like a wall of unreadable JSON text.

Pretty TypeScript Errors formats those complex type errors into human-readable, syntax-highlighted blocks.

Why I love it: It turns Type 'String' is not assignable to type '{ id: number; name: string; }' into a clear visual breakdown. It saves so much mental energy when debugging complex generic types.

4. Console Ninja 🥷

How many times have you written console.log(data), switched to your browser, opened DevTools, refreshed the page, and filtered the console?

Console Ninja displays your console.log output right inside your VS Code editor, next to the log statement.

_Why I love it: _It keeps me in the "Flow State." I don't have to context-switch to the browser just to check if a variable is null.

5. Todo Tree 🌳

As a Senior Dev, I often leave notes for myself (or my team) like:

// TODO: Refactor this later
// FIXME: This crashes on empty input

Todo Tree scans your entire workspace for these tags and puts them into a neat explorer tree in your sidebar.

_Why I love it: _It prevents "Technical Debt" from becoming "Technical Mystery." Before I push a PR, I check the tree to make sure I didn't leave any critical FIXME items behind.

Honorable Mention: The AI Assistant 🤖

Whether you use GitHub Copilot or Codeium, having an AI pair programmer is standard in 2026. I use it mostly for writing unit tests and generating boilerplate documentation. It’s not magic, but it’s a massive time-saver.

What’s in your extensions.json?
These are my "Big 5," but I’m always looking to optimize. What is the one VS Code extension you absolutely cannot code without? Drop it in the comments below! 👇

Happy Coding!

Transformer Series - Blog #3 Positional Encoding - How Transformers Understand "Time" Without a Clock ⏳

Jyoti Prajapati — Wed, 21 Jan 2026 13:55:02 +0000

Welcome back to the Transformer Series! 👋

In Blog #2, we turned words into numbers (Embeddings). We took the word "King" and turned it into a vector of numbers that captures its meaning.

But we have a massive problem.

Transformers are designed to be fast. Unlike their predecessors (RNNs), which read a sentence one word at a time (left-to-right), Transformers gulp down the entire sentence in one go.

This Parallel Processing is great for speed, but terrible for context.

If you feed the sentence "The dog bit the man" into a Transformer without help, it sees the exact same input as "The man bit the dog." It’s just a bag of words floating in space. It knows who is involved, but it has no idea who did what because it has lost the concept of Order.

Today, we are going to fix that using one of the smartest tricks in Deep Learning: Positional Encoding.

The Problem: The "Shuffled Book"

Imagine I hand you a book, but I’ve torn out all the pages and shuffled them. You can still read the individual sentences and understand the topics (Embeddings), but you can’t follow the story (Sequence).

RNNs (Old School): They read page 1, then page 2, then page 3. They know the order implicitly because they process things sequentially.

Transformers (New School): They look at all the pages at the exact same time.

To fix this, we need to write the page number on every single page before we throw them into the pile. That is exactly what Positional Encoding is.

Attempt #1: The Naive Approach (Integers) ❌
Why don't we just add a simple number to each word?

"The" = 1

"Dog" = 2

"Bit" = 3

The Issue: If your sentence is 5 words long, the last number is 5. If your sentence is 500 words long, the last number is 500. Neural Networks hate unbounded numbers. They work best when numbers are small and normalized (usually between -1 and 1). If we feed in a huge number like 500, it will blow up the gradients and ruin the training.

Attempt #2: Fractions? ❌
Okay, let's normalize it.

First word = 0

Last word = 1

Everything else is a fraction in between.

The Issue: In a short sentence (5 words), the "step" between words is 0.2. In a long sentence (100 words), the "step" between words is 0.01. The meaning of the position changes depending on the sentence length. We need a method where the "distance" between position 5 and 6 is consistent, regardless of how long the text is.

The Solution: The "Wiggly" Timestamps (Sine & Cosine)

The authors of the Transformer paper (Attention Is All You Need) came up with a brilliant solution using waves.

Instead of adding a single number (like "3") to the word, they add a whole vector of values derived from Sine and Cosine waves.

The Analogy: The Multi-Hand Clock
Imagine a clock with many hands.

The Second hand moves very fast (High frequency).
The Minute hand moves slower.
The Hour hand moves very slow (Low frequency).

If you look at the position of all the hands together, you get a unique "fingerprint" for that specific time.

Positional Encodings work the same way.

For the first dimension of the vector, we use a wave that wiggles very fast.
For the last dimension, we use a wave that wiggles very slowly.

By combining these, every single position (Index 1, Index 2, Index 100) gets a unique pattern of numbers that stays consistent between 0 and 1.

The Visual "Addition"We don't append this info; we actually add it.

Final Input = Word Embedding (Meaning) + Positional Encoding (Order)

The model learns that "Meaning" comes from the inherent value, and "Order" comes from these specific wave patterns added on top.

Show Me The Code (PyTorch)
You don't need to implement the math manually (PyTorch handles it), but here is what it looks like conceptually:

import torch
import math

def create_positional_encoding(max_len, d_model):
    pe = torch.zeros(max_len, d_model)
    position = torch.arange(0, max_len).unsqueeze(1)

    # The "Wiggle" Factor
    div_term = torch.exp(torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model))

    # Apply Sine to even indices, Cosine to odd indices
    pe[:, 0::2] = torch.sin(position * div_term)
    pe[:, 1::2] = torch.cos(position * div_term)

    return pe

# This creates a unique "timestamp" vector for every word position!

Why This is Genius ?

Deterministic: The position of the 5th word is always the same mathematical pattern.
Extensible: Because it uses waves, the model can actually learn to handle sequences longer than the ones it was trained on (it can just "continue the wave").
Distance Awareness: The math allows the model to easily calculate the distance between words (e.g., Word A is 3 steps away from Word B) just by comparing their wave patterns.

Summary

Transformers process words in parallel, so they lose order.
We fix this by adding a Positional Vector to the Word Embedding.
We use Sine and Cosine waves to create these vectors so they are unique, bounded, and consistent.

Now that our Transformer knows what the words mean (Embeddings) and where they are (Positional Encoding), it is finally ready to start understanding the relationships between them.

Next up in Blog #4: The superstar of the show. Self-Attention. (Or: How the word "Bank" knows if it's a river bank or a money bank).

Stay tuned! 🚀

How to Review Code Without Being a Jerk

Jyoti Prajapati — Wed, 21 Jan 2026 11:46:06 +0000

I still remember my first Pull Request at my first "real" dev job.

I had spent three days wrestling with a complex API integration. I felt like a wizard. I pushed the code, opened the PR, and leaned back in my chair, waiting for the applause.

20 minutes later, the notification pinged. "Changes Requested."

I opened it up to find 42 comments. The very first one read:

"Why did you do it this way? This makes no sense."

My impostor syndrome kicked down the door and started setting fires in my brain. I didn't feel mentored; I felt attacked.

Now that I’m a Senior Developer, I realize that the reviewer probably wasn't trying to be mean. They were likely just busy, tired, or lacking soft skills. But the result was the same: my morale tanked, and I became terrified of submitting code.

Code reviews are the primary way we share knowledge, but they are also a minefield for miscommunication. Here is how to give high-quality feedback without becoming the villain of the story.

1. Critique the Code, Not the Coder

This is the Golden Rule. When you use the word "You," it feels personal. When you talk about the code, it’s objective.

The "Jerk" Way:

"You forgot to close the database connection here."

The Senior Way:

"It looks like the database connection might remain open here. We should probably close it to prevent leaks."

Why it works: It shifts the dynamic from Me vs. You to Us vs. The Bug. We are on the same team, trying to defeat the spaghetti code together.

2. Ask Questions, Don't Bark Commands

Commands shut down conversation. Questions open a dialogue. As a senior, your goal isn't just to fix the code; it's to teach the junior how to think.

The "Jerk" Way:

"Rename this variable to isUserActive."

The Senior Way:

"This variable name flag is a bit ambiguous. What do you think about naming it isUserActive to make it clearer for the next person reading this?"

Sometimes, the developer actually has a reason for doing it their way. By asking a question, you give them the chance to explain (and sometimes, they might actually be right!).

3. The Magical Power of "Nitpick"

Nothing destroys the soul quite like a reviewer holding a PR hostage because of indentation or a missing trailing comma.

If a comment is purely subjective (preference) or minor style, label it.

[Nitpick]

[Optional]

[Suggestion]

Example:

"[Nitpick] I usually prefer using a ternary operator here for brevity, but this if/else works too. Feel free to leave it."

This tells the developer: "Your logic is solid, you can merge this, but here is a tip for next time." It removes the anxiety of "I have to fix everything before I am worthy."

4. Don't Be a Ghost 👻

We’ve all seen the reviewer who leaves a comment like:

"This isn't efficient."

...and then disappears into the void.

If you are going to call something out, explain why. Provide a link to documentation, a StackOverflow thread, or a quick snippet of how it could be better.

The Senior Way:

"Using .map inside a .filter here creates a O(n^2) complexity. Since this dataset can get huge, this might slow down the UI. Check out [this article on Big O notation]—we might want to use a Set here instead."

5. Praise is Mandatory (Seriously) 🏆

This is the secret weapon of great Tech Leads.

If you are pointing out 10 mistakes, find at least one thing they did well. Did they write a clean test? Did they handle a weird edge case gracefully? Tell them!

"Nice catch on that null check! I would have totally missed that."

Positive reinforcement makes people want to write better code. Constant criticism makes people want to write safe code (which is often boring and stagnant).

6. The "Step Away From The Keyboard" Rule

If you find yourself typing a comment that is longer than a paragraph, or if you and the author are going back and forth on a comment thread more than three times...

Stop.

Pick up the phone. Hop on a Slack Huddle. Walk over to their desk.

Text lacks tone. What you think is a "direct explanation" might read as "passive-aggressive shouting." A 3-minute voice conversation can resolve what 3 hours of comment-warfare cannot.

Summary: Be the Senior You Needed
Code review isn't about proving you are the smartest person in the room. It's about ensuring the team ships value safely.

Be kind.

Be specific.

Be a mentor.

Your teammates will learn more from a helpful guide than a gatekeeper.

Happy coding!

If you found this helpful, drop a ❤️ and let me know in the comments: What's the worst (or best) code review comment you've ever received?