Lazar Jovanovic is a full-time professional vibe coder at Lovable. His job is to build both internal tools and customer-facing products purely using AI, while not having a coding background. In this conversation, he breaks down the tactics, workflows, and framework that let him ship production-quality products using only AI.

We discuss:

1. Why having no coding background can be an advantage when building with AI

2. Why most of your time should go to planning and chat mode, not prompting

3. What to do when you get stuck: his 4x4 debugging workflow

4. The PRD and Markdown file system that keeps AI agents aligned across complex builds

5. Why kicking off four or five parallel prototypes is the best way to clarify your thinking

6. Why design skills and taste are going to be the most important skills in the future

7. His “genie and three wishes” mental model for making the most of AI’s limitations

8. How product, engineering, and design roles are converging—and what that means for your career

—

Brought to you by:

Strella—The AI-powered customer research platform: https://strella.io/lenny

Samsara—Saving lives with AI built for physical operations: https://samsara.com/lenny

WorkOS—Modern identity platform for B2B SaaS, free up to 1 million MAUs: https://workos.com/lenny

—

Episode transcript: https://www.lennysnewsletter.com/p/getting-paid-to-vibe-code

—

Archive of all Lenny's Podcast transcripts: https://www.dropbox.com/scl/fo/yxi4s2w998p1gvtpu4193/AMdNPR8AOw0lMklwtnC0TrQ?rlkey=j06x0nipoti519e0xgm23zsn9&st=ahz0fj11&dl=0

—

Where to find Lazar Jovanovic:

• X: https://x.com/lakikentaki

• LinkedIn: https://www.linkedin.com/in/lazar-jovanovic

• YouTube: https://www.youtube.com/@50in50challenge

• Starter Story course: https://build.starterstory.com/build/ai-build-accelerator?via=lazar (code LAZAR15 for 15% off)

—

Where to find Lenny:

• Newsletter: https://www.lennysnewsletter.com

• X: https://twitter.com/lennysan

• LinkedIn: https://www.linkedin.com/in/lennyrachitsky/

—

In this episode, we cover:

(00:00) Introduction to Lazar and professional vibe coding

(04:53) What a professional vibe coder actually does day-to-day

(09:26) Why non-technical backgrounds can be an advantage

(12:24) The importance of self-awareness

(14:42) His “genie and three wishes” mental model

(17:43) Developing taste and judgment in the age of AI

(21:46) The parallel project approach for better outcomes

(29:30) Creating dynamic context windows with PRDs

(36:56) Why elite vibe coders focus on planning, not coding

(44:43) Creating MD files to guide AI development

(50:57) Why prototyping still matters

(56:50) Why “good enough” is no longer good enough

(01:00:53) The future of engineering in an AI world

(01:05:14) What to do when you get stuck: his 4x4 debugging workflow

(01:14:27) Helping agents learn from their mistakes

(01:15:35) Why watching agent output is more important than code

(01:19:08) The incredible pace of AI development

(01:22:55) Why emotional intelligence will become more valuable

(01:28:30) How to become a professional vibe coder

(01:30:10) Why building in public is the fastest path to opportunities

(01:37:03) Final thoughts on focusing on quality over tech stack

—

Referenced:

• The new AI growth playbook for 2026: How Lovable hit $200M ARR in one year | Elena Verna (Head of Growth): https://www.lennysnewsletter.com/p/the-new-ai-growth-playbook-for-2026-elena-verna

• Elena Verna on how B2B growth is changing, product-led growth, product-led sales, why you should go freemium not trial, what features to make free, and much more: https://www.lennysnewsletter.com/p/elena-verna-on-why-every-company

• The ultimate guide to product-led sales | Elena Verna: https://www.lennysnewsletter.com/p/the-ultimate-guide-to-product-led

• 10 growth tactics that never work | Elena Verna (Amplitude, Miro, Dropbox, SurveyMonkey): https://www.lennysnewsletter.com/p/10-growth-tactics-that-never-work-elena-verna

• Lovable: https://lovable.dev

• Lovable + Shopify: https://lovable.dev/shopify

• Everyone’s an engineer now: Inside v0’s mission to create a hundred million builders | Guillermo Rauch (founder and CEO of Vercel, creators of v0 and Next.js): https://www.lennysnewsletter.com/p/everyones-an-engineer-now-guillermo-rauch

• Mobbin: https://mobbin.com

• Dribbble: https://dribbble.com

• 21st.dev: https://21st.dev

• Lovable base prompt generator: https://chatgpt.com/g/g-67e1da2c9c988191b52b61084438e8ee-lovable-base-prompt

• Lovable PRD generator: https://chatgpt.com/g/g-67e1e85fbeac8191a69b95c6d5c42ef6-lovable-prd-generator

• Felix Haas’s newsletter: https://designplusai.com

• Bauhaus: https://en.wikipedia.org/wiki/Bauhaus

• Glassmorphism: https://www.figma.com/community/plugin/1197106608665398190/glassmorphism

• UI style guide: http://uistyle.lovable.app

• Cloudflare: https://www.cloudflare.com

• Ben Tossell on X: https://x.com/bentossell

• The rise of Cursor: The $300M ARR AI tool that engineers can’t stop using | Michael Truell (co-founder and CEO): https://www.lennysnewsletter.com/p/the-rise-of-cursor-michael-truell

• Peter Thiel says AI will be ‘worse’ for math nerds than for writers: https://www.businessinsider.com/peter-thiel-ai-worse-for-math-professionals-than-writers-2024-4

• Andrej Karpathy on X: https://x.com/karpathy

• The 100-person AI lab that became Anthropic and Google’s secret weapon | Edwin Chen (Surge AI): https://www.lennysnewsletter.com/p/surge-ai-edwin-chen

• Why experts writing AI evals is creating the fastest-growing companies in history | Brendan Foody (CEO of Mercor): https://www.lennysnewsletter.com/p/experts-writing-ai-evals-brendan-foody

• Slumdog Millionaire: https://www.imdb.com/title/tt1010048

—

Production and marketing by https://penname.co/. For inquiries about sponsoring the podcast, email podcast@lennyrachitsky.com.

—

Lenny may be an investor in the companies discussed.

Happy Superb Owl Day! As my team didn't even get close to the playoffs, I'll be rooting for the Seahawks, but even more so, hoping for a fun game. Tomorrow I head out to Vegas for my first offsite with Webflow, and the first in-person company event I've been too since Auth0 nearly a decade ago. I'm looking forward to meeting my teammates in person and meeting new people. Now - to the links!

Adding Touch to PowerShell

A few months back, I traded in my Windows laptop (it was having horrible hardware issues) and moved back to Mac. I've gone back and forth over the years, and even when I was on Windows for my personal machine, my work laptop was usually a Mac, but I've decided to go back to Mac for my personal machine ... at least for a while. That being said, one of the aspects of Windows I wanted to get into more, but never got around to it, was scripting in PowerShell. I knew it had a lot of power and flexibility, but I spent most my time in WSL so I didn't really dig into it.

This post by Cassidy Williams demonstrates a simple example of this, rebuilding the touch command for PowerShell. On the offhand chance you don't know what touch does, it simply creates a new blank file with the name you specify, so touch cats.txt will create the file cats.txt in your current directory. Apparently, Windows has a command like this already, ni, but Cassidy wanted to use the same function in multiple OSes.

Invokers on the Web

Next up is a look at invoker commands by Pawel Grzybak. Invoker commands let you bind HTML elements to actions without needing JavaScript, and are available across all modern browsers (even IESafari). You can extend the built-in invoker support with JavaScript as well.

State of JavaScript Results

Last up are the results from the annual State of JavaScript survey. This is a wide ranging survey of the JavaScript, and greater web, ecosystem. It's quite a bit of data and worth your time checking out.

Just For Fun

Usually I reserve the "fun" link for music videos, but this was just too good to pass up. My buddy Todd Sharp discovered this a few days ago and it's a fascinating look at the history of the Japanese mail system. Trust me, it is absolutely cooler than it sounds, and a quick read at that. Enjoy!

More than Mail | The Culture and History of the Japanese Postal System

During the early phase of my career, I used to spend eight hours a day inside the Visual Studio IDE. Fast-forward to today, and developers spend more time delegating work than coding in an IDE.

That shift points us to something dramatically different – from writing and editing code to orchestrating coding agents. It is not just autocompletion bolted onto existing workflow, but a fundamental shift in how software is being built. The IDE still matters, but it is no longer on the main stage.

The old regime of development

In the last three decades, the IDE was central to software development. From editing to navigating, refactoring, debugging, and building, the integrated development tool was the cockpit of coders and developers. Turbo C, Borland Delphi, PowerBuilder, Visual Studio, IntelliJ, Eclipse, and, more recently, VS Code dominated the IDE market. They have been the gravitational centers of professional software development.

IDEs made perfect sense based on the approach of “human writes code, tools assist”. Every feature, from syntax highlighting to debugging to integrated terminals, was designed to keep developers productive without leaving the editor. IDEs are meant to reduce the friction and optimize the loop of intent and implementation. This also meant that the developer was the bottleneck and the decision maker at every keystroke.

Three waves of AI coding tools

The arrival of AI models targeting the developer workflow did not happen overnight. It happened in three distinct waves, each shifting the center of gravity further away from the IDE.

Wave 1 brought AI as a feature inside the IDE. Autocomplete, inline edits, and chat sidebars appeared as extensions. GitHub Copilot was the breakout example. The IDE remained the host, and AI was a guest. Developers stayed in the same seats. They just got a faster pair programmer sitting next to them.

Wave 2 moved AI into the terminal as an execution layer. CLI agents like Gemini CLI and Claude Code brought a different model. Instead of suggesting the following line, these tools accept higher-level instructions. “Fix the failing tests across this module.” “Refactor this service to use the new API.” The terminal became a place where agents do work, not just where developers type commands. The IDE was still in the picture, but it was no longer the only place where meaningful progress happened. This marked the beginning of agents taking over the traditional job of an IDE.

Wave 3 is what we are watching emerge right now. Desktop control planes that are designed around multi-agent, long-running, parallel task management. These control planes orchestrate agents that handle various development tasks a typical developer would perform in an IDE.

Within a few weeks, both Anthropic and OpenAI have released tools that hint at this trend. Anthropic’s new Claude Cowork mode gives its AI assistant direct access to a local folder so that it can read, modify, and create files in a sandbox on your machine. Around the same time, OpenAI unveiled the Codex desktop app for macOS, a command center for running multiple AI coding agents in parallel with built-in diff review and seamless handoff to your IDE.

OpenAI’s Codex app for macOS supports managing multiple agents working simultaneously on different tasks. Anthropic’s Cowork and Code introduce a desktop experience that extends agentic capabilities beyond developer-only workflows, allowing agents to read files, run commands, and operate within explicit sandboxes.

Here’s the main idea we need to focus on. Once the UI is built around orchestration driven by the control plane, the IDE stops being the “home” and becomes just another surface.

What is an agent control plane?

Since this may sound abstract, let me make it practical and concrete. An agent control plane is a desktop application that coordinates five things:

1. Tasks, meaning what needs to be done
2. Tools that the agent can use to accomplish a task
3. Permissions that explicitly allow an agent to access local resources, such as files or databases
4. Context, which is the crucial component of an agent that provides the knowledge about the codebase and the project
5. Review puts the developer in the loop for approving or rejecting the output

These functions go beyond what IDE-first workflows can do. Parallelism, where multiple agents work simultaneously in a single chat window, attempting to tackle one thread at a time. This means developers can launch multiple agents that concurrently work on backend code and frontend UI. Long-running jobs, where background tasks like test suites, large refactors, or database migrations run asynchronously, and you check the results later. And system-level actions, where agents read and modify files, run commands, and integrate with external tools within defined boundaries.

OpenAI’s Codex macOS App supports launching long-running tasks that can be offloaded to the cloud while the developer is working on local code.

In this model, the main developer interface becomes a task dashboard. Not a text editor.

The IDE becomes a second-class citizen

I wish to clarify this assertion, as the simplified version may sound incorrect. IDEs are not optional. They are not going away. But they are being demoted from the orchestration layer.

In agent-first workflows, IDEs become diff and review surfaces where you verify what agents produced. They become debugging environments for the cases where agents get stuck or produce subtle errors. And they remain the right tool for precise editing on tricky edge cases where human judgment at the character level still matters.

The rising tension is that IDEs are also agents of absorption. The real battle is not IDE versus agent. It is about where orchestration lives. Apple just announced that it integrated OpenAI Codex and Anthropic’s agents directly into Xcode, showing that IDE incumbents will fight hard to keep the IDE at the center of the developer’s world.

IDEs are not dying. They are being repositioned as high-trust verification tools.

The competitive chessboard

If orchestration moves above the IDE, the competitive landscape shifts in ways that should worry some companies and encourage others.

IDE-first companies face real pressure. If the control plane sits outside the IDE, the editor risks becoming commoditized. JetBrains, for instance, faces a strategic choice between becoming the best review-and-debug surface in an agent-first world or building and controlling the orchestration layer itself. Both are viable paths, but the comfortable middle ground of “IDE plus AI features” may not be defensible for long.

Microsoft sits in a particularly complex position. It owns Visual Studio, VS Code, and GitHub Copilot. Promoting a standalone desktop control plane would compete directly with its own IDE-centric stack. My hypothesis is that Microsoft will prefer to embed orchestration into its existing surfaces rather than build something that undermines them. Whether that strategy works depends on whether embedded orchestration can match the purpose-built alternatives.

Google has a different opening. It is already pushing a CLI-first agent path with Gemini CLI, which means it can promote orchestration across surfaces without cannibalizing an IDE business it does not have. The caveat is that success here depends on distribution and developer trust, not model quality alone.

What would change my mind

Three counterarguments deserve honest consideration. First, IDEs might integrate agents so deeply that they recapture the orchestration layer. Xcode’s moves suggest this is a real possibility. Second, desktop control planes might fragment attention. Developers already juggle too many tools, and adding another surface could face adoption resistance. Third, security and compliance requirements may constrain autonomous agent actions so severely that orchestration consolidates inside enterprise toolchains rather than standalone apps.

I would revise my position if IDEs become genuinely great orchestration layers with permissions management, background agent execution, task queues, and plugin ecosystems that make standalone control planes unnecessary.

The job description changed

The IDE used to be where software happened. In an agent-first workflow, the software is verified and reviewed.

The shift from editing to orchestration is not speculative. It is playing out right now across the tools being shipped by OpenAI, Anthropic, Google, and Apple. The next battleground will not be about which surface is prettier or which model is smarter. It will be about trust. Auditing, provenance, and the ability to answer a simple question that grows more important by the month. Who did what in this codebase, and can I verify it?

The post IDEcline: How the world’s most powerful coding tools became second-class citizens overnight appeared first on The New Stack.