There is a large shift at the moment in how people are approaching AI tools. It's one of those moments where if you don't start using them, you will be left behind. Given the large shift in capabilities recently, jumping in can seem confusing, overwhelming or even a little intimidating.
When I first started using AI for my workflow, it was slow going. I was hesitant to pick up new tools or to use them too much. It was hard to understand tokens and context, but a larger part was simply not knowing where to start. A lot of the online workshops and tutorials become outdated, fast, making them unreliable and difficult to follow.
Many people I've spoken to want to jump straight in and build agents, skills and superpowers without understanding the basics of how the tools work. Most developers want to start with 100% AI code and that's where it starts to feel hard. Starting small might feel like you're not doing enough, but it's easy to speed through these steps and move on to more complex tools.
By following these steps, you'll be able to use an AI tool to explore and understand a codebase in a structured way and have a simple workflow you can reuse.
A Practical Guide for Getting Comfortable with AI (Github Copilot)
There are many tools available for coding but I have found Github Copilot a good starting point. There are many built in tools which make it easy for those just starting out and the docs are very easy to follow.
Step One - Start Small
Before jumping in to having your AI write your code, look at your AI tool like a pair programmer. They're a junior developer just starting out; you need to give context, guide it, and review what it produces.
Copilot comes built in with features like /simplify and /explain which are great starting tools for using your AI agent
Another option is /tests which will take the selected code and write a collection of unit tests which can be used to check your code.
Utilising these build-in tools will help you to learn the capabilities of your AI faster and provide you with easy prompts that can be reused.
Step Two - Build Trust
It is very easy to take everything at face value and trust that the output is correct. It's important to take a step back and ensure that the information you're providing and the output of the tool are both correct. Just as we can make mistakes while working, so can AI and it's still your responsibility no matter which one of you wrote the code.
I suggest starting with Copilot in your IDE rather in the CLI. It's a more visual approach and can be easier to start with when doing smaller tasks.
There are two ways to talk to your agent, the first is inline and this has developed from the initial format of comment to code. Copilot has a built in chat inline where you can ask a question or assign an agent to update your work. The inline agent can be found by clicking the stars on the left side of your screen once you've highlighted your code.
This is a great tool for small changes and specific questions about sections of code.
When you want to do a large piece or build a new feature, the chat window is a better way to go. This will give you options for plan, agent and ask
These work the same as your inline chat but can be more generic or can relate to a whole file rather than just one section.
Agent mode will allow your AI agent to make code changes on your behalf by suggesting a possible solution to the prompt that you input.
It's a lot of fun seeing the agent work for the first time but it's very easy to get carried away, it's always important to trust, but verify.
Step Three - Integrate
Once you're familiar with the basics, it's time to start giving your AI more responsibility. Along with making code changes, most of the powerful AI capabilities come with debugging, exploring a new codebase and drafting implementations.
Debugging:
Code doesn't always work the way we want it to first time round. There can be issues with the syntax, missing dependencies or something just isn't looking right. AI can be a great pair programmer in these scenarios as it can be a good buddy to bounce ideas off of and to ask for help without needing to ask another member of the team.
Exploring a new codebase:
We've already looked through /explain which can be a great starting point when we need to understand a method that may not be written in a readable way. But what happens when we have a whole new codebase or a class that we need to understand?
By using the built in plan mode with a prompt guiding what is required, Copilot is able to put together a detailed document of the project or feature that you're learning.
This is an unfamiliar codebase and I need to understand what this
program does in order to extend the logic.
Can you write out a detailed investigation of this code and include
any structural diagrams you believe would be necessary to my understanding.
Drafting Implementations:
Plan mode can also be used to generate detailed code plans before assigning to an agent. These are handy because it adds another check to ensure the new code is doing what we are expecting. Once a plan has been created, you can ask questions, adapt the plan and make sure that the proposed change matches what you are asking it to do.
I would like to expand the logic of my password checker. Write a plan
that meets the following requirements:
- I would like to ensure that there are no spaces in the password
- All other validation should stay the same
- There should be test cases to match
Once you're happy with your plan, there's an option to start implementation which will assign your plan to an agent for them to work through the code changes that you have approved.
It's still important to check all test cases and to make sure that your code is building correctly as there's sometimes context missing from the work the agent is doing. Trust, but verify.
Step Four - Expand
Once there's an understanding of the fundamentals and how the tooling works practically, it's then easy to build on the existing knowledge to more complex tasks.
Once I understood how to utilise these ideas, I went on to add external MCP tools and eventually I built my first custom agent
It's important to understand when to use each skill and to refine prompts and models to receive the best possible outcome. Once you have that foundation, the options are limitless.
Confidence over complexity
Many people jump into using AI tools without fully understanding the complexities. While it's very possible to use AI completely to write 100% of code, it's important to start slow, understand where the tooling is beneficial and where human intervention is important.
For me, I enjoy the planning tools. It's where I spend more of my time and iterating through plans and ensuring they match the output I want means that I can sit back and let the agent take over the code.
This took a lot of trial and error. A lot of opening PR's and closing them because the code had compilation errors or just didn't match what I needed it to do. Sitting back and becoming more familiar with the basics meant that I could learn faster and do more with the tools.
It does still take time to learn but by slowing down, researching and asking questions of those already utilising the tools, my skills are growing faster, I'm getting more confident and there are less mistakes.
It takes time to learn today to make you a better engineer tomorrow
Top comments (0)