How AI can help you move beyond vibe coding and become an effective AI engineer faster than you think
Dear developers: Your job is safe, and it actually just got a lot better too!
A few weeks ago, I took on the task of building an end-to-end LLM app, and I added a new tool to my tech stack alongside Opik, my go-to for LLM evaluation. I used an AI-powered code editor called Cursor AI. Cursor is designed specifically for software engineers like me to leverage AI to assist in code generation. With Cursor’s help, I was able to deliver a project in a week that would have taken me months—but AI alone couldn’t have delivered it without me.
Here is what I noticed: Without knowing how to code, I would not have been able to craft the right prompts to generate meaningful code or detect and fix the errors it made. However, due to my extensive background in software engineering and my awareness of coding best practices, I can iterate with an AI assistant on my codebase, utilizing AI as a collaborative tool while guiding it to deliver working and reliable code.
AI-assisted coders today use tools like GitHub Copilot, Cursor AI, or even just copy-pasting code into AI chatbots like ChatGPT, to help them generate code. Before I tried Cursor, I was that developer copy-pasting code snippets into ChatGPT to try to speed up my development cycle or debug something. Although this approach did speed up development, it wasn’t effective in the long run because ChatGPT did not have total context on the surrounding codebase, or deeply understand my plan for my project. Cursor AI integrates deeply with your codebase, enabling developers to write, refactor, and understand code more efficiently using natural language prompts. Cursor builds on top of VS Code, adding features such as intelligent autocomplete, codebase-aware chat, and AI-assisted debugging. In this context, the AI acts as a collaborator, offering suggestions based on the context of the entire code base.
As generative language models, LLMs are actually great at code. Why? Because code is a language! So, the underlying mathematical architecture of LLMs built to model human language actually lends itself very well to coding languages as well. However, I notice they still fall short in logical decision making, such as strategically planning the project, debugging, and sensibly structuring the repo. That is where developers come in to guide them.
There is a difference between truly vibe coding with Cursor and AI-assisted coding with Cursor. Let me break it down.
👎 Vibe coding is a new approach to software development where, instead of manually typing code, developers use natural language to describe the end product, and the AI handles every step of the technical implementation. This does not require knowledge of software engineering, and I also don’t recommend this approach if the goal is to create working or reliable software.
👍AI-assisted coding is different. It’s a step beyond Cursor vibe coding. This is a new approach to software development, where programmers primarily interact with LLMs to generate code in an iterative manner. In this case, the developers are not only focused on the end result of the implementation, but also on hands-on guidance during the implementation. This is, by far, the best approach, and it requires a basic foundational knowledge of software engineering.
But the learning curve to become an excellent AI developer is now way shorter. With tools like Cursor AI and Opik, anyone can become a skilled developer and start building high-quality, reliable AI tools themselves. All you need to be an effective AI-assisted coder is a basic knowledge of software engineering best practices and core AI concepts, and you can get all this knowledge from university programs or free online courses. If you want to build AI projects, I recommend knowledge in the following areas, and have linked a few online and free courses to help you get started.
- 1-2 coding languages of your choice (python)
- Software design principles
- Data Systems
- AI Engineering handbook and online course building LLM apps
Also, AI Coding tools like Cursor AI can teach you how to be a better developer. I said you need to know how to code to be an effective AI-assisted software engineer, but I also want to point out that this tool can be used to jumpstart and accelerate learning to be a good software engineer in the first place. Once you have the foundational understanding from the courses and books above or similar, you can start coding with AI assistance and continue your learning journey through that experience.
Best Practices for Effective AI-Assisted Coding beyond Vibe Coding
After completing my first AI-assisted coding project, I’ve gathered some valuable insights about how to use an AI coding assistant properly. I have discovered some personal best practices that will help me ensure the code I deliver remains reliable while also improving my efficiency with AI assistance. There are both right and wrong ways to do this. Let me break it down.
Prompt Engineering
One of the most effective ways to maximize the benefits of using an AI Coding Assistant like the one in Cursor is to master prompt engineering. I quickly discovered that the more specific and detailed my prompts were, the better the code the AI would produce.
- Be specific: Instead of making vague requests like “write a function for X,” I learned to articulate precisely what I wanted: “write a Python function that takes a list of integers and returns only the even numbers.” If the first suggestion wasn’t quite right, I would refine my prompt by adding more context or asking follow-up questions. Cursor thrives on clarity; the more information you provide, the more effectively it responds.
- Include examples: Another useful tactic is incorporating code examples, comments, or docstrings into your prompts. Adding annotations like this with your detailed descriptions can guide it in implementing or expanding upon your ideas. I often wrote out the logic in comments or pseudo-code first and then asked the AI assistant to convert those comments into functional code. This approach not only improved the readability of the code but also helped ensure that the AI’s output aligned with my intentions.
- Use your engineering skillset: Additionally, using true engineering terminology is critical. Understanding the language of your craft, regardless of what it is, will enable you to accurately describe your requirements in a prompt and guide AI in generating the desired output. Prompt engineering is a skill; the more proficient you become at discussing what you’re trying to create in precise technical terms and details, the more successful you will be at collaborating with AI to produce something great.
Pair Programming Mindset
The best way to work with an AI coding assistant is to treat it like another developer on your team. The most productive sessions happened when I engaged in a back-and-forth workflow, asking it to generate code, reviewing the results, and inquiring about the reasoning for its design choices, then refining either the prompt or the code as needed. This collaborative approach brought out the best in both myself and the AI.
I also made it a habit to ask the AI coding assistant “why” questions when uncertain about its suggestions. Requesting explanations not only helped me learn but also allowed me to catch mistakes or misunderstandings or identify similar solutions before they became problematic. The more I collaborated with the coding assistant, the more I realized that the future of software development relies on teamwork between humans and AI.
Plan your Project and Codebase
One of the most important lessons I’ve learned is the necessity of having a plan before starting to code with AI. It may be tempting to simply open your AI tool and request it to build a feature or even an entire app by describing the end product, but this approach can lead to total chaos and a codebase you don’t understand and can’t build on or maintain. While AI is powerful, without a clear idea of how you would structure the code yourself, you risk ending up with a jumble of disconnected snippets that fail to integrate as the codebase matures.
So before I typed a single prompt or generated any code, I took the time to map out the modules, data flow, and responsibilities of each component of my app. This blueprint guided the AI, making the entire process smoother and more productive. This approach allows you to maintain control over the architecture and ensures that each piece aligns with your overall plan. And this is one of the reasons we still need developers.
🔍 Pro tip: AI works best at solving tiny, discrete, and well-defined tasks. You need to design the problem first.
Build Iteratively
Building iteratively is the key to any successful coding project, and AI-assisted projects are no exception. I quickly learned that trying to generate too much code at once often leads to confusion, bugs, and wasted time. Instead, I focused on constructing my app piece by piece, validating each part before moving on to the next.
This incremental approach made it easy to catch mistakes early, adapt to new requirements, and maintain a clean codebase. Each time I finished a small chunk, I would test and review it before proceeding to the next task. This method not only simplified debugging but also provided me with a sense of progress, momentum, and good checkpoints in GitHub.
Keeping things simple is equally important. The more complex your prompt or code structure, the more likely the AI is to become confused or produce unexpected results. I found that by concentrating on one function or module at a time, I could guide the AI to generate high-quality code that met my needs and adhered to my vision for the implementation plan. If I ever felt stuck, I would break the problem down even further.
The Importance of Debugging and Logging
When building an LLM application with a code assistant, the debugging step is where AI logging tools like Opik really shine. Collecting comprehensive logs will assist the AI coding assistant with great context for building and debugging. I logged all my traces with Opik so I could chat with my logs to better understand and debug every step of my LLM-powered app. The Cursor integration with Opik’s MCP server was a game changer because it allowed me not only to manage prompts and log traces to monitor from the app I built, but also provided context to the AI coding assistant, helping me analyze and debug issues with the app as I built it in real-time. I could see exactly what the AI was doing, the prompts it was using, and how it responded to different inputs. This level of visibility made it so much easier to spot bugs, optimize performance, and understand the behavior of my app.
One of my favorite features is the Opik Chat History extension for VSCode. I often lose track of the conversations I have with Cursor when building new features, but with this extension, all my chat sessions are synced to Opik automatically. I can review them later, share them with my team, or even post them online. This turns every coding session into a learning opportunity, and it means my thought process is never lost. Plus, with Opik’s open-source platform, I can query traces and analyze metrics. You can also take it one step further and use the traces logged in Opik to improve your prompts. One technique that works well involves fetching traces and then asking the LLM to suggest an improvement based on these traces.
🔍 Pro tip: to reduce costs while developing, use o3-mini or another smaller model for debugging, and gscale up to pt-4-turbo reasoning model once your app is live.
Refactor! Refactor! Refactor!
While using an AI assistant to code my project, I often took breaks from building new features to step back and refactor the existing codebase. Refactoring is not just a best practice; it’s a necessity when working with AI-assisted code. Early in my project, everything was confined to a single main file, which quickly became unwieldy spaghetti code – a developers nightmare. No one likes spaghetti code!
So I made it a point to refactor my code before completing the project, and along the way. I would break the code into logical modules and clean up as I progressed. These routine, periodic cleanups helped prevent the codebase from becoming overly complex or disorganized, making it much easier to maintain long term.
Each time I added a new feature or fixed a bug, I would take a moment to look for opportunities to simplify and organize the code. This not only made the code easier to work with but also enabled the AI to generate helpful suggestions as we continued to build out the codebase.
In the end, a well-structured codebase is the foundation for successful AI-assisted development, and it’s important that the human developer has communicated a clear vision for this structure and ensures the AI-generated code adheres to that vision.
🔍 Pro tip: If you’re looking for a guide for building clean reusable code, I love Miguel’s take here.
It is also important to review your code together with your AI assistant for overall quality. After a significant refactor, I prompted it to evaluate my code and provide a report. This feedback was invaluable in designing the codebase and keeping it organized in a way that was maintainable, easy to debug, and facilitated collaboration.
🏆 Final Assessment
Grade: A+ Your codebase demonstrates excellent software engineering practices:
✅ Zero duplication of business logic
✅ Excellent modular organization
✅ Clear separation of concerns
✅ Consistent patterns throughout
✅ Centralized utilities properly used everywhere
✅ Clean architecture with logical module boundaries
The structure is production-ready and maintainable. You've successfully avoided the common pitfalls of code duplication and have created a well-organized, professional codebase. Great work! 🎉
Conclusion
AI-assisted coding is not about replacing developers; it’s about empowering us. With tools like Cursor AI and Opik, you can code faster, learn faster, and deliver higher-quality software than ever before. The real magic happens when you, the developer, stay engaged by using your skillset to collaborate with AI as you build. So the future of software engineering is collaborative and efficient, and I find that exciting!
If you want to become an effective AI-enabled Engineer, then begin learning and building with AI now, and if you use it right, AI can help you achieve your goals faster than you ever thought possible.
I’m excited to see what you build! 🚀
Learn more about my tech stack:
