A practical guide to getting comfortable with AI coding tools

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, there's no small chunks, it's all or nothing.

A Practical Guide for Getting Comfortable with AI (Github Copilot edition)

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.

Stage 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 and need your guidance on what is expected.

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.

These are a great starting point and will help you to learn the capabilities of your AI tool.

Stage 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 equally 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.

While it's great to have the agent do your work and start writing code, it's always important to trust, but verify.

Stage Three - Integration

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.

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