From Unknown to Understood: Navigating Codebases with GitHub Copilot

Liatmoss — Thu, 09 Apr 2026 11:17:42 +0000

As an engineer, the nature of the job means that we are moving teams, switching to new products or changing jobs with some frequency. Even if we have been working on the same feature for years, it's impossible for one person to keep track of everything in a particular codebase. Understanding how everything fits together can be slow, error-prone, and frustrating, especially under time pressure.

Rather than treating AI as a code generator, I reframed it as an investigative partner, one that can trace execution paths, correlate logic across file structures, and surface insights that would otherwise take hours or days to uncover.

As AI coding tools evolve, it is important as engineers that we are able to keep up with the latest trends while also maintaining our productivity.
I have found it quite challenging to reframe my thinking that while it may take me all of today to get a better understanding of this particular tool, tomorrow I will be more productive for it.

And most of the time it's actually much faster to pick up then I expected it would be!

In my current team, we are working within a large codebase with code that was written by previous team members who had different "best practices" to what we currently use. Looking through the code as part of investigation or discovery was painful and took days or sometimes weeks.

Given that none of us wrote this code, or can possibly be across all of it, I created a pathway to help the team become more efficient in navigating through the code base. With the help of the steps below, we now have a structured and efficient way to conduct investigations and discoveries which save us time and effort allowing us to spend time building new features and contributing more to the code.

Step One:

The first step I took was to use the Plan agent built into Github Copilot to help with in depth investigations.
I wrote out a detailed prompt, copying and pasting details from the Jira ticket and had Copilot create a markdown doc with the investigation findings

I want your help to assist in an investigation. Explore the codebase and 
services based on the context given from the Jira ticket. 
If you are not sure on the scope or you need clarification, 
use your intuition and document assumptions clearly. 
Research based on these assumptions and if there are multiple assumptions, 
explore and compare. 
Create diagrams where required to explain the flow of the code 
and write in an easy to read and understand format. 

---
Context:
- ..
- ..

---
Requirements:
- ..
- ..

Step Two:

While this provided some great context, it was stuck in my editor or I had to manually copy it over to wherever I wanted the investigation saved. This is where I introduced MCPs to my investigations.
I added the Atlassian MCP server to my IDE which gave me the option to send the document either to a confluence page or to the linked Jira ticket.

This was really helpful in that I could assess the investigation in the .md file, confirm that it answered the requirement that I had set out and then switch to Agent mode and ask Copilot to submit the investigation to Atlassian in whatever format I needed it.

Step Three:

This worked really well for me as I was learning more about the tooling but it was quite inefficient as I had to switch between Plan mode to create the investigation and Agent mode to make any changes or to send to Atlassian.

The final iteration of my Investigator copilot was to create my first custom agent Super-Investigator and give the agent the best parts of both the Plan and Agent built in tools.

The purpose of the Super-Investigator is to:

Scans files, code and dependencies in the selected codebase
Investigate the details provided either from the Jira ticket or the specific prompt
Document and diagram relevant findings
Standardise how we view documentation keeping a consistent format between users and features
Create a confluence page with the full investigation
If a Jira ticket was provided, summarise all findings and add a comment to the ticket along with a link to the new confluence page
Collates all the investigation documentation in one place where it's easy to find based on Jira ticket reference

What Super-Investigator Produced:

With a minimal prompt of:

Use the details provided in the Jira ticket [JiraLink]

Context:
- ..
- ..

---
Requirements:
- ..
- ..

Super-Investigator was able to iterate through the code searching for key words and phrases from the ticket. The agent identified the process that the specified field flows through the system, documented and diagrammed the flow before giving recommendations of what could be simplified.

Once the investigation was completed, Super-Investigator created a confluence page in the designated spot using the Jira ticket number as a reference and included a summary of the investigation as a comment on the ticket.

This process, which manually would have taken days, was completed in approximately 10 minute including a manual check by me to ensure the information was correct (which it was).

Findings:

This process took me about two weeks to iterate through and until the next round of tools are released, I feel like I'm in a great place now to investigate and gather information from my codebase.

The Super-Investigator custom agent I created is able to look through the coded and provide a detailed investigation much faster than using the built in Plan agent as it stores more relevant data in the agent file and I need to provide less context in my prompt. The outcome is also more accurate than what I was originally getting back.

Super-Investigator is my first custom agent and I'm sure it'll get smarter as I start using it more and sharing my findings with the rest of the team. I'm excited to see what superpowers it's able to pick up next.