Over the past year and a half, I have been experimenting with AI coding tools as part of my daily development workflow. What started as simple curiosity has turned into a fundamental shift in how I write, review, and think about code. In this post, I want to share what I have learned the tools I have tried, the ones I prefer, the tips and tricks that actually work, and the philosophy I have developed around using AI as a coding partner rather than a replacement.
The Tools I Explored
When I first started exploring AI in my coding workflow, I looked at two main tools: Cursor and GitHub Copilot. Both are powerful, but they serve very different purposes and suit different types of developers.
Cursor
Cursor is an AI tool built directly into VS Code. What makes it unique is that it reads your entire project all your files, folder structure, and code patterns and uses that full context to help you. It can suggest code that fits your specific project architecture, help with debugging, and even assist with structuring folders and programs.
I did not use Cursor extensively, but from what I observed, it is an excellent tool for beginners or for anyone starting a project from scratch. Because it understands your entire project, this approach is particularly valuable for teams building enterprise AI applications. A junior developer can simply give it a command and it will implement things correctly within the project context.
GitHub Copilot
Copilot is my preferred tool. It loads as a plugin in VS Code rather than being built in, and unlike Cursor, it does not store your project data on a server or remember what you worked on last session. Every time you give it a prompt, it works purely from the current file, any files you reference, and what you ask it to do.
Some developers might see this as a limitation, but for me as a senior developer and tech lead this is exactly what I want. I want to understand my own project. I do not want the AI to understand the project and write logic its way. I want to write logic my way, and use Copilot as a smart assistant that helps me move faster software development projects.
Think of it like this: Copilot is like a knowledgeable colleague sitting next to you. You tell it what to do, give it enough context, and it helps you execute. You stay in control of the architecture and the decisions.
Choosing the Right AI Model for the Task
Selecting the right model is an important part of any enterprise AI implementation.
One thing I have learned is that not all AI models are equally good at everything. Copilot itself supports multiple models, and I choose them based on what I am trying to do:
- UI from Figma/UX designs: GPT-4o (ChatGPT)
- When I receive a design from the UX team a Figma mockup, for example and I need to convert it into a React component with forms and validation, I use GPT-4o. It is excellent for translating visual designs into clean UI code.
- Claude Sonnet (complex logic & refactoring): For anything involving complex logic conditional cell rendering in tables, multiple actions tied to conditions, intricate state management I turn to Claude Sonnet. It consistently produces cleaner, more accurate implementations of complicated logic.
- Gemini (graphical/visual tasks): I have also explored Gemini for graphically intensive tasks, though it is not something I have used as extensively.
Tips and Tricks for Getting the Best Out of Copilot
These practices are equally useful for teams building AI-powered enterprise software.
1. Give Point-Wise Prompts, Not Bulk Instructions
One of the biggest mistakes developers make is dumping a massive paragraph of instructions into Copilot. I always break my prompts down into numbered points 1, 2, 3, 4 so the model knows exactly what I want. This makes it easier to review each change and accept only what makes sense.
2. Attach Reference Files
Copilot has an attachment feature where you can attach existing files to your prompt. I use this constantly. If I am building a new component and I want it to follow the same patterns as an existing one, I attach that existing component and tell Copilot: ‘Look at this component. Copy the logic and apply the same pattern here.’ This keeps code consistent across the project without me having to re-explain everything from scratch.
3. Use Precise Technical Terms
This is probably the single most impactful tip I can share. When you use the right technical vocabulary, Copilot immediately understands what you want. For example:
- Instead of saying ‘I want to share data between components,’ I say ‘Implement Redux to share project data across sibling components.’ Copilot then creates the full Redux folder structure slices, store, provider all in one shot.
- Instead of saying ‘call the API,’ I say ‘Use Axios via the existing interceptor to call this GET endpoint.’ Copilot knows what an interceptor is, finds the existing instance in the project, and uses it correctly.
The more precise your language, the less back-and-forth you need.
4. Create Project-Level Configuration Files
For Copilot to understand your project standards, create configuration Markdown files at the root of your project. I create files like architecture.md, business.md, and copilotguide.md where I document the libraries we use, the component patterns we follow, and the conventions of the project. When Copilot loads, it reads the README and these files, and uses them as context for every generation. This is how you solve problems like Copilot defaulting to Bootstrap when your project uses Material UI you just specify it in the guide file.
5. Tell Copilot What NOT to Touch
This is a lesson I learned the hard way. When I had already made some manual tweaks to a component and then gave Copilot a new instruction, it sometimes overrode my changes because it did not know I had made them. Now I always explicitly state in my prompt: ‘Do not change any existing code. Only add the following functionality.’ This keeps your work safe and makes Copilot a much safer collaborator.
How I Review AI-Generated Code?
A common question I get is: do you review AI-generated code before running it, or do you run it first? My answer: it depends on the stage.
When creating a brand-new component, I let Copilot generate the initial structure, run it once to see what it looks like, and then start refining from there. After the first look, every subsequent change gets a careful review. I read what Copilot changed, understand why, and only accept changes that make sense to me.
For code quality, our team has a rule: no component should exceed 500 lines. If it does, we refactor. For refactoring, I use Claude Sonnet it is excellent at condensing bulky code, identifying redundant logic, and restructuring components cleanly.
We also use Copilot’s PR review feature. When creating a pull request, Copilot automatically reviews the code and suggests corrections or improvements another layer of quality control that has caught real issues.
Debugging with AI
Debugging is one area where AI assistance has been particularly valuable. My approach:
- If I know roughly where the issue is, I describe the expected behavior and actual behavior in the prompt, and ask Copilot to fix it.
- If I have no idea where the bug is hiding, I ask Copilot to add console logs throughout the code at every critical step. I then run the app, copy the log output from the console, and paste it back into the prompt. Copilot analyzes the logs, identifies the root cause, and proposes a fix.
- If the fix still does not work, I switch models. If Claude Sonnet did not solve it, I try GPT-4o. Switching models often unlocks a different approach, and in most cases, the issue gets resolved by the third attempt.
One helpful side effect of using Copilot for development: it automatically adds inline comments and documentation to every section of code it writes. This means I can later copy a comment into a prompt and tell Copilot: ‘Work only on this section.’ It focuses precisely on that part without touching anything else.
These workflows become even more valuable in large-scale enterprise software development projects.
The Real Efficiency Gains
If I had to rate the efficiency improvement AI has brought to my work, I would give it a 9 out of 10.
Here is a real example. We received a requirement to implement a telephony feature a soft phone module that allows users to make and receive calls directly from a web browser. The client gave us a four-month estimate to build this. With Copilot’s help, I had a working module in three to four days. Copilot introduced me to the JSIP library, which is used for implementing SIP-based soft phones in the browser, set up all the necessary files and configurations, and helped me implement the calling service end-to-end. Without AI, I genuinely believe this would have taken months.
Similar AI-driven engineering approaches are helping organizations accelerate product delivery across healthcare, financial services, manufacturing, and other enterprise domains.
My Philosophy: AI as a Coding Partner, Not a Replacement
The most important thing I want to share is this: I am always involved in coding alongside the AI. I never hand everything over and walk away.
Sometimes Copilot gives me logic and I implement it as-is. Other times, I write the logic myself and then hand it to Copilot, saying: ‘Use this logic, not your own.’ I stay engaged with every change. I know what is in my codebase because I put it there or consciously approved it.
This approach has also helped me grow as a developer. Because I am actively reading and reviewing everything Copilot generates, I keep learning. I am exposed to new patterns, new libraries, and better ways of doing things but I always understand them before they land in production.
In summary, the best way to use AI in coding is not to depend on it blindly, but to collaborate with it intelligently. Use it to move faster. Use it to explore unfamiliar territory. Use it to handle repetitive scaffolding. But always keep your own understanding of the project intact. That understanding is what makes you a good developer the AI is just a very capable tool in your hands.
Looking to accelerate your enterprise software development with AI?
Our engineering teams help organizations build scalable AI-powered applications, modernize legacy systems, and reduce development time using practical AI engineering workflows.
