Deep Dive into Cursor: AI Production Vibe Coding

AI coding tools are making waves in the development community. AI agents are now so good at coding that they are becoming extremely useful for speeding up the development lifecycle. When combining AI Agents with leading reasoning large language models, the results are quite staggering. AI coding tools are not ready to take over the world just yet, but they are quickly becoming a valuable resource for developers, DevOps engineers, and Site Reliability folk.

This article is going to focus on a tool I recently discovered called Cursor, or Cursor.AI to give its its full name. To the completely transparent, I have no affiliation with Cursor, and I am not paid for this content, or sponsored by Cursor.

That being said. Cursor is awesome!

My Dev Background

I’ll start by saying I am not a developer, by that I mean a traditional developer who sits and writes line by line code for an application or product. I can read a script in most languages and understand roughly what’s going on. But my experience in Development work comes from the Operations and Infrastructure perspective. My official job title is DevSecOps Engineer, which means I have to write production Infrastructure as Code.

My SDK of choice is either Terraform or CDK. I am much better a Terraform and HCL, I can write HCL for pretty much anything straight from the official documentation, CDK (TypeScript) on the other hand, I have struggled over the last 2 years to pick it up – however I am now at a level where I can write code, debug code and write unit tests – so I’m ok and can get by.

What Does Cursor and Vibe Coding Bring to the Table

Alright, so what’s the big deal? Is it just another fancy autocomplete? Not even close. This is where the idea of “vibe coding” comes in, and for someone like me, it’s a total game-changer.

“Vibe coding” is less about writing code and more about directing it. It’s the difference between being a bricklayer, meticulously placing each brick, and being the architect who describes the vision and has a team of robots do the heavy lifting. You set the “vibe” or the intention—”Create a new S3 bucket with a standard lifecycle policy,” or “Refactor this clunky function to be more readable”—and the AI gets to work.

This is where Cursor shines. It’s not just a text editor with a bolted-on chatbot. It’s a fork of VS Code, so all my extensions and keybindings worked right out of the box, which was a huge plus. But the AI is woven into the very fabric of the editor.

Remember how I said I struggled with CDK and TypeScript? With Cursor, that struggle is pretty much gone. Instead of spending 30 minutes hunting through documentation to figure out the exact syntax for a particular AWS construct, I can just open a chat panel and say, “@Codebase, create a new IAM role with these specific permissions and attach it to this Lambda function.”

Cursor scans my entire project (@Codebase is a literal command, and it’s brilliant), understands the context of my existing code, and then generates the new code as a diff. I see the red lines of what’s being removed and the green lines of what’s being added. I’m still in control. I can review the changes, ask for modifications (“Actually, make that policy more restrictive”), and then accept them with a click. It turns a painful, context-switching nightmare into a fluid conversation.

But Its Not Perfect

Look, as much as I’m gushing about this, let’s get real for a second. This stuff isn’t magic, and if you go in thinking the AI is going to do your job for you, you’re going to have a bad time. It’s an assistant, a powerful one, but it’s far from perfect.

First up, the models. Cursor lets you switch between different AI models, like OpenAI’s GPT-4o or Anthropic’s Claude 3.5 Sonnet. This is cool, but it’s not immediately obvious what the trade-offs are. One model might be faster but dumber, while another is a creative genius for Python but writes Terraform like it’s its first day on the job. You have to experiment, and that takes time.

Then there’s “Max Mode.” This is basically the “unleash the beast” button, letting the AI use its most powerful reasoning and a massive context window to look at your whole project. The results can be incredible, but it’s often slower and, depending on your plan, can burn through your usage credits like a rocket. It’s a sledgehammer, and not every problem is a nail. Using it for simple stuff is overkill and inefficient.

The biggest issue, though, is that these are reasoning models, not understanding models. That’s a critical distinction. The AI doesn’t know that your S3 bucket needs to be secure; it has just seen billions of lines of code where S3 buckets were made secure. This leads to the two biggest problems: mistakes and hallucinations.

The AI will, with absolute confidence, write code that is just plain wrong. It might use a deprecated function, get the arguments in the wrong order, or write a security rule that has a gaping hole in it. It’s on YOU to catch that. You are still the expert. If you don’t know what good code looks like, you won’t be able to spot when the AI messes up.

Worse than mistakes are the hallucinations. This is when the AI just straight-up invents things. It’ll call a library function that doesn’t exist or reference a parameter for a CDK construct that it completely made up. It sounds plausible, it looks like real code, but it’s a fiction. You can waste a lot of time debugging a hallucination, cursing the official documentation before you realize the function you’re looking for never existed in the first place.

Finally, there’s the lack of context. Even with powerful features that scan your codebase, the AI can sometimes miss the plot. It might not understand that a particular variable is set in a different file, or it might ignore a crucial comment you wrote explaining a weird edge case. It gets tunnel vision. You prompt it to fix one thing, and it does so without considering the four other things that change will break. It’s a reminder that you’re the one holding the full picture, and you can never fully delegate that responsibility.

Cursor Will Not Replace the Developer – But it can certainly help them out!

So, Is Cursor, or any AI for that matter, going to make developers and engineers obsolete? Definitely not at the moment, maybe in 10 years time (who knows). Anyone who tells you otherwise is either trying to sell you something or has never tried to get an AI to solve a truly complex problem.

The whole concept of “vibe coding” is exciting, and it’s a taste of the future, but it’s not quite ready for primetime on its own. It’s a fantastic way to blast through boilerplate code or get a scaffold for a new component, but it falls apart when faced with real complexity. The AI has no genuine understanding; it’s a hyper-advanced mimic. It can’t grasp the business logic, the long-term architectural goals, or the subtle nuances of why your company’s legacy system is built in a very particular, very strange way.

This brings me to the most important point: you still need to know your stuff.

To get the best out of a tool like Cursor, you can’t just be a “prompter.” You need a solid foundation in the code you’re working with. Why? Because you are the quality control. You are the senior partner. The AI will confidently give you code that is buggy, insecure, or just plain inefficient. If you can’t read the code and understand it, you won’t be able to spot those mistakes. You won’t know when to accept its suggestion, when to ask for a revision, or when to just delete its output and write the darn thing yourself.

The AI is a force multiplier. It takes your existing skills and elevates them. For me, it bridges the gap in languages where I’m less confident, like TypeScript, allowing my infrastructure knowledge to be translated into functional code much faster. It automates the boring, repetitive parts of my day, freeing me up to focus on the hard problems: system design, security posture, and reliability.

So, no, Cursor won’t be taking my job yet. But it has absolutely become an indispensable part of my toolkit. It makes me faster, more efficient, and lets me work on a broader set of problems without getting bogged down in syntax. It’s a partner, not a replacement. And in this industry, having a partner that never sleeps and has memorised the internet is a huge advantage.