How AI-Powered “Vibe Coding” Helped Me Write 140,000+ Lines of deployable Code—And What It Means for Engineering

I’ll be the first to admit: I didn’t invent the term Vibe Coding. But when I stumbled across this approach to AI-assisted software development, I decided to run a bold, private experiment. The question was simple: Could one developer, supported by AI, build a massive, well-documented, thoroughly tested product in a fraction of the usual time?

After 1,500 sessions (yes, I counted) with my AI partner, I wound up with over 140,000 lines of code—including robust documentation, test suites, and most of the core functionality I had envisioned. Here’s the story of what I built, how I built it, and what it means for the future of engineering.

The Private Experiment: A 140,000+ Line iPaaS

I challenged myself to create a new workflow engine / iPaaS platform from scratch. Think of it as a fully automated environment designed to orchestrate node-based workflows, manage logging and error handling, and dynamically load complex “plugin” nodes. It’s the kind of project that typically takes months—if not years—of back-and-forth in larger teams.

But here’s what happened:

• 1,500+ AI Sessions: Over time, I iterated relentlessly with the AI, brainstorming features, solving bugs, and exploring new architectural patterns.

• 140,000+ Lines of Code: By the end, I had a functional engine that included everything from secure credential management and integrated logging to advanced unit-testing frameworks.

• In-Depth Documentation: Every single folder includes a dedicated README.MD capturing design decisions, usage instructions, and domain knowledge to keep the AI (and any human contributors) aligned.

• Thorough Testing: From the very start, I wrote (and AI-assisted in writing) both unit and integration tests to validate every piece of core logic.

Vibe Coding: A Conversational, AI-Driven Programming Technique

The term “Vibe Coding” went mainstream on February 3, 2025, thanks to a tweet by Andrej Karpathy, co-founder of OpenAI and former Head of AI at Tesla. He framed it as a conversational approach: you give brief instructions to a large language model (LLM), and the AI does the coding. Karpathy saw this technique as ideal for quick, low-stakes “weekend hack” projects—though he also acknowledged that the AI can get lost with complex requirements, sometimes resulting in a mess of unrelated tweaks until something finally sticks. Regardless, Vibe Coding gained swift traction in the developer community, and by March 2025, the Merriam-Webster Dictionary already recognized it as a “Trending” term.

In my own deep-dive experiment, however, I learned that Vibe Coding can be far more than a fun side project—it can supercharge every stage of the development cycle, from initial requirements to architecture, coding, testing, and documentation. The AI acts like a partner: proposing everything from boilerplate snippets to complex logic and pointing out potential pitfalls. Yet as the developer, I remain the conductor—steering each session, setting standards, and testing ruthlessly to ensure things run smoothly.

The “Vibe Coding” Workflow: Guiding Principles

1. Detailed Requirements

Even for minor features, I draft explicit specifications. Clear goals keep the AI from wandering into incorrect assumptions, so each session is sharply focused on achieving defined outcomes.

2. “AI Memory” in the Codebase

Every folder contains a readme.md outlining objectives, domain knowledge, and architectural notes. These serve as reference points for the AI, preventing it from unintentionally reinventing or duplicating code across multiple sessions.

3. Domain-Specific Trackers

For each module, I maintain a checklist of to-dos, known bugs, performance aims, and test results. Both I and the AI consult these trackers, ensuring we share a consistent snapshot of what’s completed and what still needs attention.

4. Relentless Supervision

While the AI produces a lot of code, I review every line—running architecture checks, performing code reviews, and enforcing quality standards. Without rigorous oversight, AI output can introduce subtle (but serious) pitfalls.

5. Test-Driven from Day One

Every new feature immediately comes with unit and integration tests—often generated with the AI’s help. This rapid feedback loop ensures flawed code is caught and corrected promptly.

6. Cursor Rules (Guard Rails)

Finally, I establish “Cursor Rules” that dictate how the AI handles branching, security checks, logging, and more. These guard rails prevent the AI from drifting into aimless or duplicative code.

Why It Worked

1. Breaking Down Complex Tasks

Rather than tackle massive features head-on, I decompose them into smaller subtasks. The AI excels in these tighter contexts, consistently delivering targeted code.

2. Continuous Context

Thanks to the README-based “memory,” the AI could check domain facts before coding. Across hundreds of sessions, it occasionally “hallucinated,” but this documentation kept the project on track.

3. Early and Frequent Testing

Pushing tests to the forefront (rather than as an afterthought) gave the AI immediate performance data—enabling quick pivots when something fell short.

4. Iterations Over Perfection

I embraced short dev cycles, refining features in steps rather than aiming for flawless code in one shot. That minimized the risk of a major architectural misstep going unnoticed until late in the game.

Vibe Coding isn’t just for quick weekend hacks—it can be a potent, iterative way to build serious software, provided you keep a firm hand on the wheel. By combining explicit requirements, tight documentation, robust testing, and clearly defined rules, I found that AI can genuinely accelerate innovation without devolving into chaos.

The Ugly Bits: Hallucinations and Code Duplication

Of course, Vibe Coding isn’t a silver bullet. The AI still made mistakes—sometimes it repeated code structures across modules or confidently proposed logic that didn’t align with my architecture. I had to keep a watchful eye on:

• “Hallucinations”: Where the AI invented code or APIs that didn’t actually exist.

• Duplicative Boilerplate: Occasionally, the AI would produce near-identical blocks of code for different modules, leading to maintainability concerns.

• Version Control Confusion: Rapid session changes sometimes made it tricky to track which iteration had introduced a bug, so I had to be extremely disciplined in my Git workflow.

None of these were showstoppers, but they underscored the importance of human oversight and strong engineering practices.

Why This Matters for Engineering

1. Days Instead of Months: Tasks that might have taken me a month to prototype were often done in a few days with AI assistance. That changes the entire lifecycle: more frequent releases, more feedback loops, and faster pivots.

2. Smaller, Focused Teams: It’s not unreasonable to imagine a single developer (or a tiny squad) delivering major functionality—provided they set up the AI collaboration effectively.

3. Documentation Finally Feels Manageable: Because the AI can help with writing readme.md files, code comments, and even diagrams, I no longer had to worry about falling behind on docs. They evolved alongside the codebase.

4. Real-Time Architectural Feedback: Over 1,500 sessions, I used the AI to brainstorm structural changes, weigh design alternatives, and even gauge performance trade-offs. The constant iteration prevented big design mistakes from hardening into the final product.

Where to Go from Here

If you’re intrigued, don’t just dive in blindly. My experience suggests you should:

1. Start with Clear Requirements: If you’re fuzzy on what you need, the AI will be fuzzy in delivering.

2. Create an “AI Memory”: Keep per-module docs and trackers that both you and the AI can reference.

3. Engage in Ruthless Testing: The AI can turbocharge your dev, but errors slip through if you don’t maintain a rigorous test culture.

4. Plan for Iterations: Smaller cycles = more frequent course corrections.

5. Stay Vigilant: Ultimately, you’re still the engineer. The AI is a remarkable helper but not a replacement for human judgment.

A New Paradigm for Tailor-Made Software

One major advantage of open source—exemplified by Shopware—has always been the freedom to customize deeply without being forced into a rigid SaaS model. But until recently, creating bespoke features or handling complex edge cases came at a high cost, often requiring large teams and lengthy timelines. Thanks to AI-driven “Vibe Coding,” that barrier is quickly evaporating. Combining robust open-source foundations with automated, AI-assisted development means organizations can now build highly specialized solutions—faster and far more affordably than ever before. Instead of being constrained by one-size-fits-all SaaS platforms, teams can own and adapt their code to address unique business processes, even spinning up entire systems in a fraction of the time and cost. This marks a genuine paradigm shift: the days of “custom means expensive” are rapidly giving way to a new, more agile era of enterprise software engineering.

Final Thoughts

I started this experiment half-expecting to abandon the AI approach at the first sign of trouble. Instead, I found that with disciplined project management and a willingness to iterate, Vibe Coding became a force multiplier. Writing a full iPaaS platform—from basic node definitions to advanced telemetry—in a matter of weeks felt almost surreal. Yet it demonstrated something profound: we can now accomplish in weeks what once took months or years, without sacrificing robustness or thoroughness.

The future of engineering might look more like this: smaller teams working faster, guided by AI-based co-pilots, high-quality code that’s fully documented, thoroughly tested, and infinitely adaptable. If my 1,500-session, 140,000-line experiment taught me anything, it’s that this “vibe” is real—and it’s here to stay.

Are you ready to give it a try? I’d love to hear your thoughts in the comments. And if you want my "Cursor AI" rules comment as well 😉

If you want to read my thoughts on "How AI is going to change eCommerce" - have a look here