Vibe Coding

If you've ever found yourself stuck in the frustrating cycle of switching between your code editor and a ChatGPT tab, you understand the main limitation of conventional generative AI. The process of copying, pasting, and adapting code generated without context isn't just tedious—it's inefficient and breaks the creative flow of development. AI, in this model, is an intelligent spectator, but never a real participant in your project.

This is where a new philosophy, dubbed "Vibe Coding," promises to redefine the paradigm. It's a programming technique where interaction with AI happens natively and contextually. The developer describes the expected result in natural language, and the artificial intelligence, immersed in the source code, generates solutions directly, like a true programming partner.

This change fundamentally transforms the developer's role. We stop being just "code writers" to become "intent architects" or "orchestra conductors." The focus shifts from micromanaging syntax to macromanaging logic, allowing a speed of prototyping and experimentation previously unimaginable and accelerating the future of software creation.

But does this really work? If you know nothing about software development and try this, you'll tell me yes, but does it really? Let's do a quick analysis before the conclusion.

The Relationship with "Cursor"

Cursor is a fork of VS Code. The Cursor team took the open-source code from Visual Studio Code (VS Code), which is maintained by Microsoft, and created a modified version of it.

Many developers are already very familiar with VS Code, which greatly facilitates a new experience with Cursor.

• Familiar base
• Extension compatibility
• AI focus

If you've already had any experience in VS Code trying to use extensions to add an AI, you'll definitely love Cursor. Even when installing Cursor, it already asks if you want to import all your settings that are already defined in VS Code.

The experience is notably different, although Cursor is built on the VS Code base. The main difference lies in the depth and how artificial intelligence is integrated into the development experience.

The connection between "vibe coding" and "Cursor" is direct and fundamental. Cursor is a code editor designed specifically to facilitate and enhance the practice of "vibe coding." It calls itself an "AI Code Editor" and integrates artificial intelligence functionalities directly into its development environment.

What we have in improvements using Cursor:

• Total Project Awareness (Codebase-Aware): This is the main differentiator. Before any interaction, Cursor can index your entire project, every file, dependency, and function definition. When you ask to refactor code, the AI isn't just seeing that isolated snippet; it knows how this change will impact in several places. This results in much smarter refactorings that consider the software architecture as a whole, not just one file.

• Conversational and Immersive Editing (Inline AI): The interaction doesn't happen primarily in a chat panel, but directly in the code. When selecting a block, you open a prompt in place of your code. You're not asking to generate new code elsewhere, you're commanding the AI to sculpt and modify existing code in real-time. The feeling is of programming in pairs with AI, shaping logic with natural language commands, which eliminates the context break of "copy and paste."

• Chat that "Reads" Your Files: Even Cursor's chat panel is smarter. Instead of pasting code snippets to give context, you can simply type @ and mention files from your project, and the AI instantly loads that complete context for the conversation, allowing you to ask much more complex questions.

Cursor is the tool that operationalizes the "vibe coding" concept. While "vibe coding" is the methodology or development philosophy.

Coding with Cursor

To put Cursor to the test, I decided to embark on a classic project: creating a Tetris game from scratch, using only the free version of the tool. My intention was to understand how far AI could take me without costs.

The Free Plan Barrier

The first 40 minutes were a mix of productivity and frustration. The initial AI generated the basic project structure, separating HTML, CSS, and JavaScript. However, as the logic became more complex, the system started to struggle. There came a moment when the AI introduced a bug and simply couldn't get unstuck.

No matter how much I explained the error, pointed out the problematic function, and suggested different approaches, the responses were repetitive or generated new failures. The AI got stuck in a loop, unable to solve the problems it had created. It was the clear limit of the AI model available in the free plan.

The Turning Point: The Upgrade to Paid Account

Tired of fighting the machine, because I didn't want to put my hands on the code, I decided to upgrade to the Pro plan. And the result was immediate. Boom! On the first try, I described the same problem that held me back for more than half an hour. The paid AI's response was different: it not only found the bug, but also explained the root cause and applied the correction precisely. The difference in reasoning capacity was striking.

With the main obstacle solved, I took the opportunity to question the code architecture. Initially, the AI had placed all the game logic in a single JavaScript file. When asking for improvements, it quickly suggested and implemented a refactoring, separating the code into more organized and cohesive modules.

Here's Cursor already with the Dracula theme improvement.

And our simple result, but remember that I didn't even touch the code.

If you don't want to suffer, it's good to pay, the experience was much better.

To unlock Cursor's full potential, with access to the most powerful AI models, there are two main paths: subscribe to the editor's Pro plan or configure your API key from a service you already pay for.

• Cursor Pro Subscription (The Integrated Plan): This is the simplest option and, for most developers, the most advantageous. For a fixed monthly fee (currently $20), you get unlimited and worry-free access to the best models on the market, like GPT-4o and, crucially, Claude 4. It's the "all-inclusive" experience, ideal for those who use AI intensively and don't want to worry about token consumption.

• Using Your Own API Key (Bring Your Own Key - BYOK): If you already have credits on platforms like OpenAI or Google AI, Cursor allows you to insert your API key and pay as you go. This can be an alternative for those who use AI very sporadically.

Watch Out!

With all this code generation power at your fingertips, the temptation to accelerate without looking to the sides is great. This is where the main skill of the modern developer comes in: productive skepticism. That's why, "Watch Out!"

Simply asking what you want from the AI and accepting the result because "it seems to work" is a dangerous trap for real applications.

For prototypes, proofs of concept, or simple scripts, this speed is transformative.

However, when the application is real, critical, with customer data, performance, security requirements, and a maintenance lifecycle (SDLC), "coding by vibe" becomes dangerous. Generative AI is a copilot, not the pilot. And a copilot is only useful if the pilot knows how to fly the plane, understands the instruments, and is ultimately responsible for the flight's safety.

The truth is that to use Cursor in professional development, or any other system with AI, you need to be even more competent than before. AI doesn't diminish the need for knowledge; it amplifies it. The focus only changes: from writing code line by line to reviewing, architecting, and validating code at a higher level.

Deep Domain of Programming Fundamentals and Language

AI can generate code that works, but it can be inefficient, non-idiomatic, or simply bad. Without solid knowledge, you won't know the difference.

• What did the AI do?: You need to be able to read and understand each line of code the AI generated or proposed to change. If you can't explain why the AI chose one approach over another, you're working with a code "black box."

• Performance: AI can generate an algorithm with much greater complexity than necessary. Only a developer with experience in data structures and algorithms can identify and correct this.

  A developer might ask for a function to see if a list has duplicates and receive this.

  def has_duplicates_brute_force(list):
      """
      Checks if the list contains duplicates by comparing each element
      with all others.
      """
      for i in range(len(list)): # 2 Fors here.
          for j in range(i + 1, len(list)):
              if list[i] == list[j]:
                  return True  # Found a duplicate!
      return False # No duplicate found.

  It works, but let's do an analysis.

  • For a list of 10 items, it makes about 10×10=100 comparisons.
  • For a list of 1,000 items, it makes about 1,000×1,000=1,000,000 comparisons.
  • For a list of 100,000 items (common in e-commerce), it makes 100,000×100,000=10,000,000,000 (10 billion) comparisons!

  While in reality a function like this would be much more performant.

  def has_duplicates_optimized(list):
      """
      Checks if the list contains duplicates using a set
      for almost instant search.
      """
      seen_items = set() # Creates an empty set.
      for item in list:
          if item in seen_items:
              return True # The item was already seen, it's a duplicate!
          seen_items.add(item) # Adds the item to the set of already seen items.
      return False # No duplicate found.

  • For a list of 10 items, it makes 10 operations.
  • For a list of 1,000 items, it makes 1,000 operations.
  • For a list of 100,000 items, it makes 100,000 operations.

• Language Idioms (Idiomatic Code): AI can write Python code that looks like Java, or JavaScript that ignores ES6 best practices. This has improved a lot since you know how to ask.

  An AI could do this.

  # Works, but it's not how you write in Python.
  # Looks like a direct translation from Java/C++.
  fruits = ["apple", "banana", "orange"]
  i = 0
  while i < len(fruits):
      print(fruits[i])
      i += 1

  It's verbose, requires manual management of index i, and there's a small risk of logical errors.

  But an experienced developer would do this, which is safer and universally understood by any Python programmer.

  # The Python way of doing things.
  # Direct, readable, and safe.
  fruits = ["apple", "banana", "orange"]
  for fruit in fruits:
      print(fruit)

Solid Knowledge of Software Architecture and Design Patterns

AI is excellent at tactical tasks (creating a function), but limited in strategic decisions (structuring the system).

• Macro vs. Micro Vision: Where should this new component live in the architecture? Should it be a separate service? How does it communicate with the rest of the system? AI doesn't have the business context or long-term objectives to make these decisions. This remains a purely human responsibility.

• Applying Principles: You need to understand principles like SOLID, DRY (Don't Repeat Yourself), and KISS (Keep It Simple, Stupid) to guide the AI. You can ask Cursor: "Refactor this class to follow the Single Responsibility Principle," but you need to know what that principle is to validate if the result is correct.

Security Mindset

This is perhaps the most critical area. AI is trained on a vast body of internet code, which includes numerous examples of vulnerable code.

• Input Validation: AI may forget to validate and sanitize user inputs, opening doors to SQL Injection or Cross-Site Scripting (XSS) attacks.

• Secrets Management: AI may accidentally suggest that an API key or password be placed directly in code. An experienced developer knows this should be managed through environment variables or a secrets service.

• Dependency Choice: AI may suggest a library for being popular in its training data, without knowing it has known vulnerabilities (CVEs), is deprecated, or has an unreliable maintainer, introducing a security risk throughout the software supply chain.

Debugging and Critical Analysis Skills

When AI-generated code fails, the responsibility to find and fix the bug is 100% yours.

• Root Cause: If you don't understand the code, you can't use a debugger effectively to trace execution and find the root cause of the problem. You'll be stuck in a trial-and-error cycle, asking the AI to "try to fix" without a real diagnosis.

• Active Questioning: The most important skill becomes the ability to question the AI. "Why did you use this library?", "Is there a more performant way to do this?", "What's the trade-off of this approach?"

---

Conclusion: Scared, Not Impressed

At the end of this experience, the predominant feeling isn't impression, but a certain fear. I was scared by how easily a developer could fall into the illusion of productivity, when in reality they're just exchanging one task (writing code) for another, even more expensive one: being a constant supervisor. If we add up the time spent analyzing generated code, asking for countless refactorings, debugging obscure logic, and correcting poor architectural decisions, the promise of time savings falls apart.

When we let AI be too autonomous, we completely lose control, because the project grows exponentially in terms of complexity and looking at all this becomes unsustainable, coming to the conclusion that "it would have been better to do it from scratch to have total control and knowledge." The time to debug code that wasn't written by me is much longer. I need to stop to analyze and understand the logic, whereas if I had done it I would already know what it was about.

But this view is incomplete. Yes, I see immense value in tools like Cursor, but not as responsible for "coding." Its true power emerges when we see it as an omnipresent consultant: a partner who has already read your entire project, understands the context, and is ready to answer a question or suggest an improvement without me needing to copy and paste code into another window. The value isn't in delegating the task, but in eliminating friction to obtain qualified help.

For simple tasks and helping me debug something, it might make sense, but letting it structure things is still far off.

I didn't understand the term Vibe. This to me seems more like suffering than a Vibe. Vibe is supposed to be happy! Vibe coding is asking for trouble. If this ever takes off for real, we'll have the famous Prompter Engineer being hired.