DEV Community: Sarkar

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?"