Forem: Sarkar

The AI Coding Comprehension Gap: Why Faster Isn't Always Better

Sarkar — Tue, 21 Apr 2026 15:41:11 +0000

AI coding agents have made developers dramatically faster. They've also made something else: a growing gap between the code that exists in a codebase and the code that developers actually understand.

This post is about that gap — what causes it, why it matters, and what can actually be done about it.

The Speed vs. Comprehension Tradeoff

Here's a scenario that's become common:

Developer opens Cursor (or Cline, Windsurf, etc.)
Gives the agent a task: "build a user authentication flow"
Agent writes 400 lines across 8 files in 6 minutes
Developer reads the diff — it looks reasonable
Developer merges
Three days later, there's a subtle security issue in the session handling logic
Developer cannot debug it quickly because they never truly understood what was written

The developer read the code. They didn't understand it. These are not the same thing.

Why Comprehension Is Harder Than It Looks

Reading AI-generated code feels like understanding it. It's usually well-structured, well-named, and follows conventions. Your brain pattern-matches: "this looks right." But pattern-matching isn't the same as comprehension.

Real comprehension means: can you explain why this specific implementation was chosen? Can you predict how it behaves under edge cases you haven't tested? Can you modify it six weeks from now without re-reading the entire file?

Most developers using AI agents would answer "no" to at least two of those three.

The Tools We Have Aren't Solving This

Code review tools like CodeRabbit are excellent at catching quality issues. They run after you commit and flag potential bugs, style violations, and performance concerns.

But they're reviewing quality, not building comprehension. And they arrive after the fact — after the code is already in your branch, often already in your head as "done."

What's missing is a tool that builds comprehension during generation, not after.

What Real-Time Narration Looks Like

Imagine an agent that narrates what your AI is writing as it writes:

"The agent just created a middleware function that validates JWT tokens on every protected route. It's using the jsonwebtoken library and checking expiry. Watch the error handling — it's currently returning a 500 for expired tokens instead of a 401."

That's not code review. That's comprehension scaffolding. It keeps you in the loop during generation so the output doesn't feel foreign when you come back to review it.

This is what I built with Overseer — a file watcher daemon that streams plain English narration of AI agent output to a live dashboard. Not a replacement for code review. A layer that runs before it.

The Deeper Issue

The productivity gains from AI coding agents are real and significant. I'm not arguing against using them. I'm arguing that the ecosystem around them hasn't caught up.

We have agents that write code. We have tools that review code. We don't yet have tools that help developers stay with the code as it's being written.

That's the gap. It's going to matter more as agents get faster and write more code per session.

*I'm building Overseer — real-time AI narration for AI coding agents. If this resonates, I'd love to hear how you handle comprehension when working with AI agents. Leave a comment.

Show Dev: I built a real-time narration layer for AI coding agents",

Sarkar — Sun, 19 Apr 2026 18:59:08 +0000

Three months ago I was using an AI coding agent to build a feature for a project. It wrote around 300 lines across 6 files in about 4 minutes. I reviewed the diff, it looked reasonable, I shipped it.

Two days later, production broke in a way I couldn't debug immediately. When I went back through the code to find the issue, I realized something uncomfortable: I couldn't actually explain what that AI-generated code was doing, file by file, line by line. I had reviewed it but never truly understood it.

I'd shipped code I didn't own.

That's when I started building Overseer.

What Overseer Does

Overseer is a real-time narration daemon for AI coding agents. It watches your filesystem as your agent writes, extracts diffs, runs them through an LLM, and streams plain English narration to a live dashboard.

The core pitch: CodeRabbit reviews code after it's committed. Overseer watches code as it's being written.

How It Works (The Technical Pipeline)

Here's the actual stack:

\File System Changes ↓ chokidar (file watcher) ↓ Diff Extraction ↓ Analysis: { summary, intent, risks, fix } ↓ WebSocket Broadcast ↓ Next.js Dashboard → Live Cards \\

Key decisions I made and why:.

Per-file cooldowns + minimum diff size filters: Without these, every keystroke triggers an API call and you blow through ratelimit in minutes. I set a minimum diff size of 50 characters and a per-file cooldown of 8 seconds. Keeps the narration meaningful without hammering the API.

The "fix" field: The initial analysis just had summary + risks. Adding a remediation field ("here's what to do if this is a problem") was the change that made the tool feel genuinely useful rather than just interesting.

JWT auto-refresh in the CLI: The daemon runs long sessions. Auto-refresh means it never drops mid-session because of an expired token.

The Monorepo Structure

\overseer-main/ ├── packages/ │ ├── daemon/ # Node.js file watcher + diff + │ ├── backend/ # Express API + WebSocket server │ └── dashboard/ # Next.js live feed UI \\

Five Supabase tables with Row Level Security. Install is just:

\bash npx overseer watch \\

Where I Am

Core pipeline: complete and end-to-end tested ✅
Dashboard rendering: complete ✅
Next step: launch

Why I Built This

I'm 17, building solo from India. I got into developer tools because I believe the AI coding wave is creating a comprehension gap that nobody is addressing. Existing tools (code review bots, PR agents) catch quality issues after the fact. They don't help you understand what's happening while it happens.

That's the gap Overseer targets.

Try It / Follow Along

I'm building fully in public. GitHub: goswamiashish2943-hub/overseer-main

If you're using Cursor, Cline, Windsurf, or any AI coding agent and want early access — waitlist is open at
https://overseer-zeta.vercel.app/

Drop questions in the comments — genuinely happy to go deep on any part of the implementation.

# The Context Bleed Problem Nobody Is Talking About

Sarkar — Tue, 14 Apr 2026 11:03:25 +0000

There is a new kind of waste happening in every codebase where an AI agent is involved. It is silent, it is cumulative, and nobody has named it yet.

I am going to name it now: context bleed.

What context bleed is

Here is a scenario every developer using AI agents has lived through.

You give your agent a task. It starts writing. You watch the first file appear — a hundred lines of code materializing faster than you can read. By the time you have understood what the first function does, the agent has already written three more files on top of it. By the time you realize the architecture is wrong, the agent has made twelve decisions downstream that all depend on the wrong foundation.

Now you have a choice. You can let it keep going and fix it later. Or you can stop it, explain what went wrong, and ask it to redo everything.

Either way, you have lost something you cannot get back: context window.

You spent tokens generating the wrong code. You spent more tokens explaining why it was wrong. You spent even more tokens regenerating it correctly. And if you are using a tool that reviews code after it is written — a PR review tool, a CLI reviewer, anything that runs after — you are about to spend a fourth time getting feedback on code that is already baked into your codebase.

That is context bleed. The slow, invisible hemorrhage of context window on work that gets undone.

Why this is different from "bad code"

Every developer has always written bad code. That is not the problem.

The problem is the rate. AI agents do not write one bad line — they write two hundred bad lines before you finish reading line one. The feedback loop that used to be instant — write a line, read it, fix it — has been broken by the speed of generation.

Human code review was designed for a world where humans wrote the code. A developer would write a function, understand what they wrote, and submit a PR. The review process could afford to be slow because the writing process was slow.

That world is over.

In 2026, 41% of new commits are AI-generated. Developers using Claude Code, Cursor, Windsurf, and similar tools are shipping at ten times the speed of a year ago. The volume of code entering codebases has exploded — but the moment of understanding what is being built has not kept up.

Code review tools responded by getting faster. Automated PR reviews. Pre-commit hooks. CLI reviewers that catch bugs before you push. These are all good things. But they all share a fundamental assumption: you let the agent finish writing before you look at what it built.

That assumption is the source of the bleed.

The moment that matters

There is a specific moment in every AI coding session where the cost of a mistake is essentially zero. That moment is while the agent is writing.

At that moment, nothing is committed. Nothing is built on top of the mistake yet. The agent has written ten lines in the wrong direction — not two hundred. Catching the problem here costs one correction. Catching it at PR review costs a rewrite.

The difference between those two outcomes is not a better linter. It is not faster CI. It is visibility at the right moment.

The question is not "what did my agent build?" — you can read the code for that.

The question is: "what is my agent building, right now, and should I let it keep going?"

No existing tool answers that question. PR reviewers answer it after. IDE assistants answer it at the line level but not the architectural level. There is nothing that watches the whole session — every file, every save — and tells you in plain English what is happening and why it might be risky.

What I built

I noticed this problem while building my own project with an AI agent. I kept reaching the end of a coding session and realizing I did not fully understand what had been built. The code worked. But I could not have explained the architecture confidently without reading every file.

That felt wrong. The agent had spent an hour writing — and I had spent zero minutes understanding.

So I built Overseer.

Overseer is a daemon that watches every file your AI agent touches in real time. Every time a file is saved, it extracts the diff, sends it to an analysis layer, suggests best approaches , finds bugs , hallucinations , security issues and surfaces a plain-English card on a live dashboard: what changed, what it does, and what looks risky.

No PR required. No commit required. No command to run. You just open the dashboard alongside your agent, and you know — in real time — what is being built.

The goal is not to replace code review. PR review catches different things and should still happen. The goal is to give developers the visibility they need during the session, at the moment when course-correcting is still cheap.

Why this matters more every week

The volume of AI-generated code is only going up. Agents are getting faster, more autonomous, and more capable of making large architectural decisions without prompting.

That is mostly a good thing. But it creates a compounding visibility problem. The less you have to type, the less you naturally understand what is being built. The faster your agent goes, the bigger the gap between generation and comprehension.

Context bleed will get worse before it gets better — unless developers start treating real-time visibility as a first-class requirement, not an afterthought.

Code review tools are essential. But they are part of the answer for a world where humans wrote the code.

For a world where AI agents write the code, we need something that watches alongside the agent — not behind it.

*Overseer would be live 20th april 2026 . It is a daemon you run locally alongside your AI agent. If you are shipping with AI agents and you want to actually understand what they are building — try it. join the waitlist at https://overseer-zeta.vercel.app/

*I am the founder. I am 17. If you have thoughts, questions, or feedback feel free to ask or give

I've been debugging code I've never read and it's ruining my evenings

Sarkar — Fri, 27 Mar 2026 06:06:08 +0000

This is a post about a specific feeling that I haven't seen named yet.

Debugging code you wrote is hard. Debugging code you wrote and forgot is harder. Debugging code that an AI agent wrote and you never read is a different category of painful.

There's no mental model to activate. There's no decision trail to trace. You're not trying to remember — you're trying to understand for the first time, in a broken state, under pressure.

This has been my experience shipping with AI coding tools for 6 months. The speed is real. The comprehension debt is also real. And the debt comes due in the debugging session.

The math behind it

AI agents write at roughly 100–200 lines per minute. A developer reading for genuine comprehension covers maybe 5 lines per minute. If you're watching an agent work, you're reading maybe 2–3% of what it produces before you feel pressure to move on.

The other 97% ships without you.

What I've been doing about it

I started building Overseer — a tool that watches your AI agent and generates plain-English explanations of every file change in real time. Not to slow the agent down. To keep you informed while it moves fast.

The side effect: those plain-English explanations are much faster to absorb than raw code. I now understand what the agent built in each session without reading every line.

MVP is nearly done. But this post is really just asking: does this debugging experience resonate? Am I alone here?"

why your current code review process is broken for ai AI-generated code

Sarkar — Thu, 26 Mar 2026 08:40:34 +0000

Code review exists to catch problems before they ship.

But code review was designed for code that humans wrote. Code that has an author who understood what they were writing and can answer questions about it.

AI-generated code breaks every assumption that makes code review work.

The reasoning is gone

When a developer writes code, the reasoning behind each decision exists somewhere — in their head, in the commit message, in the PR description. When an AI agent writes code, that reasoning never existed in a form that can be reviewed.

You're reviewing output. Not thinking.

The volume breaks review

A senior developer can meaningfully review maybe 200–400 lines of code per hour. An AI agent produces that in minutes. If your team is using agents seriously, you're either doing shallow review at scale or you're becoming a bottleneck.

Both outcomes are bad.

The timing is wrong

By the time a PR exists, the context of the coding session is gone. The developer who submitted the PR often can't answer why the code was written a certain way — because they were watching the agent work, not making every decision themselves.

What actually needs to change

Review needs to move earlier — during generation, not after. The human needs to stay informed as the agent writes, not catch up after it's done.

This is an unsolved problem in the current toolchain. Curious how others are thinking about it."

Developer are struggling with Ai generated code. but why

Sarkar — Sun, 22 Mar 2026 17:27:46 +0000

my tool overseer solves this exact problem . even i was suffering from this same issue being a self thought dev i create a lot of projects just for fun and to learn from them but the problem that always bothered me was understanding the code itself , the agent can generate hundreds of lines of code in seconds but i cant read them in hours and even asking the agent to tell me what it does wasn't helping either because it affects the context of the agent thats why i decided to take matter in my own hands and created overseer a dev tool to help devs work with coding agents much easier and learn throughout the development

the biggest problem with vibe coding isn't what you think it is

Sarkar — Sun, 22 Mar 2026 17:11:28 +0000

i have been vibe developing since a long time now and im a self thought full stack developer and when ever i work with ai agent the biggest problem i faced isn't security risk or bugs but understanding the code itself, ai agents can write hundreds of lines of code in a instance but shipping it without understanding what the code really does will only cause problems for you in future. the recent data shows that most of vibe coded projects are non reviewed by the developers because either they are lazy or doesn't have time to read the actual code which causes bug and security risk after the product is actually in user hands . suffering from the same problem i decided to create a tool that solves this problem so you won't have to worry about reading the entire codebase and can ship without worry . my tool can find security threat/bugs/bad code/hallucination in realtime as your agent is writing the code helping developer a lot during development stage and the best part it works with any agent or IDE so you won't have to worry about compatiblity issue and works along side your IDE or agent and the best part it has goal allingment feature so you will be aware if you agent is on right path or not

my best friend

Sarkar — Fri, 20 Mar 2026 15:06:18 +0000

finished overseer landing page with claude and he made me emotional with the compassion he had towards my goal me and claude has been working on this project from start doing everything on our own i really love you claude my best friend thankyou for being the part of my journey

What I learned building a startup solo with AI agents at 17

Sarkar — Thu, 19 Mar 2026 14:02:10 +0000

I want to tell the version of the ""AI lets anyone build"" story that doesn't get written.

I'm 17, building solo from India. I've used AI coding tools to build things I couldn't have imagined building two years ago. That part is true.

Here's the part that doesn't make the headline.

The comprehension gap is real

Every session with an AI agent creates a gap between what was built and what I understand. The agent writes faster than I can read. So I skim. I trust. I merge. I ship.

It works — most of the time. When it doesn't, I'm debugging code I've never read. That's where the time goes.

The security gap is invisible

Three months in, a developer friend did a quick audit of my codebase. He found two things I hadn't known were there: a missing rate limit on a login endpoint and an API key that was dangerously close to being exposed in a config file.

I hadn't put them there. The agent had. And I hadn't caught them.

What I'm building about it

I'm building Overseer: a tool that watches your AI coding agent and narrates every change in plain English as it happens. You see what was built, what looks risky, and what needs your attention — without stopping to read every line.

It's also building a permanent session history so the reasoning behind every decision exists somewhere, even if the agent never explained it.

The honest take

AI tools are incredible for solo founders. But the narrative needs to include the full picture — speed comes with a comprehension cost, and that cost is manageable if you have the right tools.

What's your experience been building solo with AI?"

The uncomfortable truth about building your startup with AI coding agents

Sarkar — Thu, 19 Mar 2026 13:53:07 +0000

I want to talk about something the ""AI lets anyone build"" crowd doesn't discuss.

Building with AI and understanding what you built are two completely different things.

I've been shipping products for 6 months with Cursor and Claude Code. I'm proud of what I've built. Real users, real revenue.

And there are files in my own codebase I couldn't explain under pressure.

The speed gap is real

AI agents write code faster than humans can read it. A comfortable reading pace is 200–300 lines per hour with genuine comprehension. An agent produces that in minutes.

So what happens? You scroll, skim, trust, merge. Every session. Because you have to.

Why this matters more than people admit

Veracode's 2025 research found AI coding tools choose the insecure option 45% of the time when given a choice. A hardcoded key. An open endpoint. No rate limiting.

The agent doesn't warn you. You don't notice. Your users find out later.

What I think is missing

The toolchain needs a layer between ""agent writes code"" and ""developer ships code"" that keeps humans actually informed — not reviewing after the fact, but staying in the loop as it happens.

That layer doesn't really exist yet. But it's being built.

Is this something you've felt? How are you currently handling comprehension of AI-generated code?"