Times have changed, and now we are in the era of Artificial Intelligence. AI tools are becoming an integral part of our daily lives, and I am no exception to this trend. My journey with AI tools has been nothing short of transformative, both personally and professionally.
Especially in the field of software development, AI tools have transformed the way we work, making tasks more efficient and allowing us to focus on what truly matters: creativity and problem-solving.
Yes! Correct, creativity and problem-solving.
In this article, I want to share my experience/learnings/tips and tricks with Copilot, Claude Code, LLM models, etc. and how they are impacting the way I work and think.
Beginning:
-
Earlier, we used to write code manually, which was time-consuming, and we got paid for it to think and eventually to solve the problems through code and the tech available to our disposal.
-
Code was the monopoly of developers, but more than code, it was the thought process that mattered.
-
We were developing our thought process in our minds, then trying to implement it through code. Still, we were not sure if it was the best way to solve the problem.
-
AI tools like Copilot, Claude Code, and other LLM models have revolutionized the way we approach coding.
-
They assist in writing code, suggesting improvements, and even debugging, which saves a lot of time and effort.
For example, copilot is reviewing the code and suggesting improvements on the fly.
- These tools analyze vast amounts of data to provide insights and suggestions that we might not have considered.
- The best part is that they are not just limited to code generation; they also help in understanding the problem better and finding optimal solutions.
My Experience with AI Tools:
-
I'm just getting started with all these tools, and I have already seen a significant improvement in my productivity and the quality of my work.
-
It helps to focus on what truly matters: designing systems and problem-solving.
-
It also helps me to search the web faster, question my thought process, and find/suggest better solutions. (In some cases only!!)
-
They are not just another tool; they are assistants that enhance our capabilities and allow us to achieve more in less time.
-
I started with Copilot, integrated it with my IDE, obviously, it was free for some time, and it was good enough to get started. I started giving some instructions to perform tasks and update the code.
-
Failed!!!
-
What I wanted to get was not what I got. I was not able to get the expected results, but I was mind-blown by the capabilities of the tool.
-
Moving forward, I learned it all boils down to how you ask the question and give more Context.
-
Also, it matters which LLM model you are using. More on this later.
-
After trial and error, I found out that the more Context you provide, the better the results you get. But the issue with this approach is that it consumes a lot of tokens, and you end up paying a lot.
-
You have to focus on token consumption and how to optimize it, along with providing enough Context.
So far, I have used Copilot, Claude Code, Cursor with LLM models like OpenAI's GPT-3.5 and GPT-4.1, Antrophic sonnet 3.7 and 4. Each has its strengths and weaknesses, but they are all good enough to produce code and help you solve problems.
Let's talk about some of the key takeaways from my experience with these AI tools:
Tips and Tricks for Effective Use of AI Tools:
- Define Your Problem Clearly: Before using AI tools, take a moment to define the problem you are trying to solve clearly. The problem statement document will help the AI understand your requirements better and provide more accurate suggestions.
- Breakdown tasks into smaller chunks: Instead of asking the AI to solve a complex problem in one go, break it down into smaller, manageable tasks. It will make it easier for the AI to provide relevant suggestions and solutions. Because LLM models have a context window, after that, they forget the previous Context.
- Provide enough Context: The more Context you provide, the better the AI can understand your requirements. Include relevant information, examples, and constraints to help the AI generate more accurate and useful code.
- Iterate and Refine: Don't expect the AI to get it right on the first try. Use the suggestions as a starting point and iterate on them. Refine your queries and provide feedback to the AI to improve its understanding of your requirements.
- Experiment with Different Models: Different AI models have different strengths and weaknesses. Experiment with various models to find the one that works best for your specific use case. For example, currently, I see Claude Code to be better at coding tasks, while Gemini 2.5 Pro is more efficient in planning and brainstorming.
- Separate dev and prod environments: Always use a separate environment for development and production. They can generate code that may not be thoroughly tested or optimized, so it's essential to validate the code before deploying it to production. NEVER give an agent access to the production environment.
- Human reviews are still essential: Models can assist in generating code, but they are not a replacement for human expertise YET. Always review the generated code to ensure it meets your standards and requirements.
- Commit work frequently: Generating code is not faster than ever before. Commit your work frequently to avoid losing progress and to keep track of changes. It also helps in identifying issues early in the development process.
- Switch models: If you find that one model is not providing the desired results, don't hesitate to switch to another model. Each model has its strengths, and sometimes a different model can yield better results.
- New conversation for each task: Start a new discussion for each task to ensure that the LLM model is focused on the specific problem at hand. This helps in maintaining clarity and Context, avoiding confusion from previous interactions.
- Integrate tools into your workflow: Use tools that enhance your workflow, such as Copilot code reviews, Code Rebit, Taskmaster, Turbo Console, Context7, etc. These help in automating repetitive tasks and improving productivity.
- Clearly say to think first, then execute: Always instruct the model to think through the problem before generating code. List out pros and cons, edge cases, etc., to create thoughtful and efficient solutions.
- Rule of Start, Pause and Continue: When working on complex tasks, use the "Start, Pause, and Continue" approach. Start working through the to-do list for each task, pause at the end of the task for your review, and then wait for explicit ok to proceed further.
- Focus on designing the system: Brainstorm the system design and architecture before diving into coding, use Gemini or Grok to help you with this.
- Prepare ADR (Architecture Decision Records): Document your architectural decisions and reasoning to maintain clarity and consistency in your project. It helps in understanding the rationale behind design choices and aids future development.
- Use Rules for each model: Define clear rules and guidelines for your workflow in GEMINI.md, .copilot-instructions, etc. This helps in maintaining consistency and ensures that the AI tools align with your coding standards and practices.
- Keep an eye on token usage: Be mindful of token consumption, especially when working on a big task. Optimize your queries to reduce token usage and perform some manual work instead of relying solely on AI tools.
These are the key takeaways after working with Copilot, Claude code and cursor for a while.
I'm still learning and exploring the capabilities of these software tools, and the future holds even more exciting possibilities. They are not just a trend; they are here to stay and will continue to evolve, making our lives easier and more productive.
Going forward, I plan to share how I use these tools in my daily workflow, along with specific examples and case studies, to build projects and enhance productivity.
Thanks for reading.