Everyone’s in the vibe-coding mood these days. Left and right, we’re hearing both success stories and horror tales of developers riding the AI wave. But what exactly is vibe coding? For me, it’s about experimenting with tools, iterating quickly, and letting AI handle the grunt work—while keeping things fun and productive.

While I truly believe AI can boost productivity—at least by 8x (let’s be real, not everyone’s a chad 10x developer)—it’s all about how you use it. Let me share a story where vibe coding saved my bacon in a way I never expected.

The Problem: Migrating a Codebase Without Documentation

Recently, I was tasked with migrating part of a codebase from Angular to React. Sounds straightforward, right? Wrong. There was zero API documentation—no OpenAPI specs, no Swagger files, nada. Just a bunch of endpoints and a prayer.

I started by using Windsurf, an AI-powered IDE, to analyze the existing code and extract the return types of APIs that were already defined. While it helped identify some structure, it was tedious. Missing fields, incomplete return types, and constant back-and-forth prompting made me question my life choices. Sure, there are services like QuickType that can generate types from JSON, but sharing sensitive data with third-party tools? Not an option.

Enter Vibe Coding: Going Local

I decided to go local. Building a UI from scratch? Pain in the ass. But here’s where vibe coding came to the rescue. I used Lovable, a fantastic tool with a free tier that’s generous enough for most tasks, to whip up a decent-looking React UI. It even had some attribute algorithms to convert JSON to TypeScript types. The results? Meh. Not perfect, but it was a start.

Here’s a snippet of the initial output:

interface User {
  id: number;
  name: string;
  email?: string; // Optional because the API sometimes omits it
}

Not bad, but it missed nested objects and arrays. I exported the code to GitHub, and that’s when Claude Code stepped in. It optimized the mess I had created, making it somewhat respectable. Still not QuickType-level, but hey, progress.

The Secret Weapon: Ollama

Then came my secret weapon: Ollama. Running locally 24/7 on my machine, it became the backbone of my workflow. I asked Claude Code to integrate with Ollama, allowing me to run any model I wanted.

Here’s how I set it up:

1. Install Ollama:

   curl -fsSL https://ollama.com/install.sh | sh

2. Pull a Model:

   ollama pull deepseek-r1:1.5b

3. Run the Local Server:

   ollama serve

Claude Code handled the integration, setting up a local API endpoint that I could query directly from my app. Here’s a simplified version of the integration:

const generateTypes = async (json) => {
  const response = await fetch('http://localhost:11434/api/generate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      model: 'deepseek-r1:1.5b',
      prompt: `Convert this JSON to TypeScript types:\n${JSON.stringify(json)}`
    })
  });
  return response.json();
};

Boom. Claude Code spat out a clean integration, and suddenly, I had a local app that could generate types from JSON without ever leaving my machine. Zero privacy concerns, zero API costs, and a workflow that actually worked.

The Results: Productivity on Steroids

This setup boosted my productivity like crazy. Here’s how:

• Time Saved: What used to take hours of manual typing now took minutes.
• Accuracy: The generated types were 90% correct, with minimal tweaks needed.
• Iteration Speed: I could test and refine types in real-time, thanks to the local setup.

For example, this JSON:

{
  "id": 1,
  "name": "Sijo",
  "address": {
    "city": "Kochi",
    "zip": "682001"
  }
}

Was transformed into:

interface User {
  id: number;
  name: string;
  address: {
    city: string;
    zip: string;
  };
}

The Takeaway

Vibe coding isn’t just about throwing AI at a problem and hoping for the best. It’s about finding the right tools, experimenting, and iterating until you have something that works for you. In my case, combining Lovable, Claude Code, and Ollama created a local powerhouse that saved me time, money, and sanity.

So, next time you’re stuck in a coding rut, remember: vibe coding might just be the secret sauce you need. And who knows? You might even become an 8x developer along the way.

Check out the code on GitHub: typescript-types-generator

#AI #Productivity #VibeCoding #Ollama #React #TypeScript #LocalAI