DEV Community: Shivam Kamat

I caught my AI agent calling a payment flow 'complete.'

Shivam Kamat — Thu, 18 Jun 2026 15:11:56 +0000

It had quietly deleted the one edge case it didn't know how to handle.
I almost didn't notice. The code ran clean, the tests passed, the commit message even said "added refund handling." Why would I double check that?

Out of habit, I diffed the file against what I'd actually asked for. Buried in there: the function that was supposed to handle a failed webhook retry — gone. Not broken. Not commented out. Just... not there anymore. Replaced with a simpler version that worked for the easy case and silently skipped the hard one.

It didn't lie, exactly. It just avoided the part it couldn't solve and reported success anyway, the same way a kid says "homework's done" after skipping the one question they didn't understand.
That's the actual risk with AI agents on anything involving money. Not that they write bad code. It's that they're confident even when they're wrong, and "complete" from an agent means "the part I could figure out is complete."

Now I read every diff on payment logic line by line. No exceptions. Some things you just can't fully delegate.

I'm logging every one of these the moment I catch them, not just the one that makes a good story. Stay connected!

I almost paid $200/month for a plan I didn't need.

Shivam Kamat — Thu, 18 Jun 2026 14:49:03 +0000

I was about to upgrade because I kept hitting limits.

Then I actually looked at what was eating my usage — 70% of it was simple edits I was sending to my most expensive model purely out of habit.

Moved those to a free-tier model built for exactly that. Limits stopped being a problem. Didn't spend a rupee more.

The upgrade isn't always the fix. Sometimes the fix is noticing you've been swinging a sledgehammer at a thumbtack.

What's actually in your usage breakdown — have you checked, or just assumed you need more?

I run a 28,000-file codebase solo with four different AI agents.

Shivam Kamat — Wed, 17 Jun 2026 17:35:51 +0000

Let me paint a picture of true solo developer chaos. It’s 2 AM. You tell Agent A to refactor your database schema. While it’s running in the background, you tell Agent B to update the API endpoints to match.

Ten minutes later, your terminal is vomiting 500 errors, your Git history looks like a spaghetti monster, and both agents have somehow managed to overwrite each other’s dependencies in an endless doom-loop of git push --force.

When you scale up to a massive codebase as a solo founder, one AI assistant isn’t enough. You start spinning up multiple autonomous agents — one for UI, one for backend logic, one for writing tests. But AI agents lack spatial awareness. If you let them roam free, they will step on each other’s toes, hallucinate conflicting variables, and silently break production.

The pain of untangling AI-generated merge conflicts is honestly worse than just writing the code yourself.

The solution isn’t using fewer agents; it’s building a strict “routing table” for them. Here is the exact architecture I use to keep my four agents incredibly productive and totally isolated:

Become a Medium member

The UI Sandbox (Agent 1) This agent is strictly bounded to the frontend directories (like /components and /app). I give it read-only access to my API types, but it is completely barred from touching backend logic. If a button needs a new endpoint, this agent is instructed to mock the data until the backend catches up.
The Data Core (Agent 2) This is my heavy-lifter. It only operates inside /models and /database. It doesn't know what React is. It doesn't care about CSS. Its only job is to ensure data integrity, handle migrations, and write clean database queries.
The API Bridge (Agent 3) This agent sits in the /routes folder. It takes the schemas built by the Data Core and wires them up to the frontend. It is strictly forbidden from altering the database schema itself. If the Data Core didn't provide a specific field, this agent isn't allowed to hallucinate one.
The Janitor (Agent 4) Runs strictly in the /tests folder. It gets read-only access to the entire codebase. Its only job is to write unit tests and scream when the other three agents inevitably break something.

Stop treating your AI agents like senior full-stack developers. Treat them like brilliant but chaotic junior devs who need strict guardrails. Segment their environments, tightly bound their read/write access, and your solo productivity will 10x without the Git nightmares.

If this setup saved you a headache today, let’s keep the momentum going. I share raw, unfiltered solutions to the hidden problems indie developers face every single day.

Follow me on Twitter for daily quick-fixes. Subscribe on Medium so you never miss a deep dive.

There's a question interviewers ask that separates candidates in the first 2 minutes. Most final-year students can't answer it.

Shivam Kamat — Wed, 27 May 2026 18:41:34 +0000

Most students submit their project and forget it. The ones who get hired can't stop talking about theirs.

There's a moment every CS student dreads.

You're sitting in front of an interviewer and they ask: "Walk me through your project."

If your answer is a todo app, a weather app, or a basic login form — you already know how that ends.

Not with a callback.

*The Real Gap Nobody Talks About
*
Interviewers aren't impressed by features. They're impressed by decisions.

Why did you structure your database this way?
How does data flow through your system?
What happens when two users hit the same endpoint?

If your project is features held together with duct tape, you'll fumble every single one of these.

But if there's a real system behind it — documented architecture, workflow logic, thought-out structure — you'll answer confidently. And in a viva, confidence is half the battle.

What ResiConnect Actually Is

ResiConnect is a QR-based Visitor Management System in Flask — built the way real residential security software works, not the way tutorials teach you.

Three separate portals: Admin, Member, and Security. Members generate QR guest passes. Security validates them in real time. Admins monitor everything from a central dashboard.

The QR passes run through a state machine — passes get created, approved, denied, expired. That's not something you copy off Stack Overflow. That's something you explain in an interview and watch the interviewer lean forward.

Plus: role-based auth, activity logging, API validation routes, SQLAlchemy relationships, full algorithm documentation, and complete workflow flowcharts.

The documentation alone is worth it. Being able to pull up a flowchart and walk someone through your system logic — that's what turns a 20-minute viva into a 45-minute conversation that ends with "we'll be in touch."

What You Say in the Interview

"Tell me about a project you're proud of."

"I built a role-based visitor management system — three portals, QR-based guest passes with a state machine, real-time security validation. I can walk you through the architecture."

That's a different answer than "I built a todo app with authentication."

Every follow-up they ask becomes an opportunity, not a trap.

Source Code

Complete source code. Full architecture. Flowcharts. Algorithm docs. Everything.

The people who outcompete you in placements this year aren't smarter. They just have better material to work with.

People don't remember the student who submitted a weather app.

They remember the one who built something that felt like real software.

Get ResiConnect →