Pavan Kumar T V

CTO | Technology Leader

AI-Assisted Development: Finding the Right Balance

When Andrej Karpathy introduced "vibe coding" in February 2025 - describing it as fully surrendering to AI assistance in development - I laughed. Not because it was wrong, but because I'd accidentally been living in that future for months.

I've spent 25 years building software, from founding my own startup (MineWhat) to leading teams across BRIDGEi2i, Trilogy, and now Stryber. I've gone from typing every character to basically having an AI do most of the work. And I have some thoughts.

The Reality Check

Let me tell you about last weekend. I was adding a new feature and found myself in this familiar dance:

Me: "Add a component for user preferences with dark mode and notification settings." AI: spits out 80 lines of code Me: scan code, fix an architecture mistake, patch a security hole AI: updates code Me: push to staging

Total time: 15 minutes. Five years ago? That would've taken at least 2 hours. That's what AI dev tools promise—but there's a catch.

Finding the Sweet Spot

After watching teams across different companies use AI, here's what I've learned:

What AI Does Well

  • Writing boilerplate code that would make your fingers hurt
  • Suggesting code improvements that make sense
  • Writing documentation better than most of us ever did
  • Coming up with test cases for edge cases you forgot

Where Humans Need to Stay in Charge

  • Architecture decisions that will haunt you for years if done wrong
  • Security stuff (I still cringe at some AI-suggested auth code)
  • Planning the overall flow—you can't just ask for a whole feature in one go

Our Approach (After Some Painful Lessons)

At Stryber, we didn't get our approach from someone's Medium article. We figured it out by trying few times:

1. Clear Lines

I tell every developer: "Let AI write the implementation details, but you own the architecture." This isn't just a nice saying—it's the difference between code we can maintain and a future nightmare.

2. Teaching Our Team

We've spent a lot of time teaching our developers how to talk to AI tools effectively. The gap between someone who can direct AI well and someone who can't is often the difference between shipping this week or next month.

A Real Example

A few weeks ago, we needed to create an application to "AI-fy" our process. Here's what we did:

Our Workflow

  • One Designer sketched the UX and key interfaces on figma
  • We used AI to write each component, but we carefully reviewed all the logic
  • All done by 1-dev with help of Cursor

We finished in weeks what would have taken months and many devs before. But—and this is crucial—we didn't just blindly "accept all" what the AI wrote.

What Actually Works

Based on what's gone well (and what blew up in our faces):

1. Start With Small Stuff

I remember when a dev used AI to generate an entire NLP system in one go. It looked perfect... until we found nothing works beyond intial cases. Now we:

  • Begin with non-critical parts
  • Gradually use AI for more important stuff as we learn its limits
  • Keep track of how it affects our code quality and speed
  • Change our approach based on what actually happens

2. Make Sure You Understand It

My one non-negotiable rule: If you can't explain how the code works, you can't commit it. This means:

  • Reviewing AI-generated code just as carefully as human code
  • Writing down what we learn for the team
  • Keeping humans in control of big design decisions
  • Never letting AI make security decisions without human checks

3. Use It Where It Makes Sense

We use AI most where we get the biggest bang for our buck:

  • Quickly building UI components
  • Creating tests and docs
  • Coding well-defined, isolated features
  • Converting between similar technologies

How We Work Now

In our daily work:

  • We use AI to write standard features faster
  • We always have humans responsible for architecture and security
  • We make sure everyone understands the code they're committing

What's Coming Next

Based on actually using these tools:

  • AI will get much better at understanding what you're trying to do
  • Development workflows will change to fit human-AI teamwork
  • We'll need new tools specifically to check AI-written code
  • Team structures will change to focus more on architecture and review

Here's the honest truth: The "vibe coding" future Karpathy described is already here for many of us. But the best teams aren't the ones who blindly accept whatever AI generates—they're the ones who thoughtfully use AI while keeping human judgment in the loop. The future belongs to developers who use AI as a tool, not those who get replaced by it.