Explore agentic & autonomous workflows with GitHub Copilot

Welcome · 5 min

Understand the code. Trust the tests.

So what Today you will learn how to explore an unfamiliar codebase and improve test coverage.

Our focus today

1 Explore unfamiliar code

Use Copilot to map the repository, find entry points and understand how the pieces fit together.

2 Find test coverage gaps

Review existing tests and identify behaviours, edge cases and error paths that need coverage.

3 Add and verify tests

Use Copilot to write meaningful tests, run them and check the results against the code.

What you need

GitHub Copilot access

A GitHub account with access to GitHub Copilot.

The GitHub Copilot app

Installed on your computer and signed in with that account.

Node.js 22.13 or later

Tailspin Toys, the practice repository, runs on Node.js.

Duration: 15 minutes

Meet the repository: Tailspin Toys

Today's repository github-samples / tailspin-toys ↗ A public sample site for a fictional game crowdfunding company, built with Astro and a local SQLite database. Treat it as code you have never seen before.

1. Create your own copy

Work in your own repository so you can raise issues later. Open github-samples/tailspin-toys ↗, choose Use this template → Create a new repository, keep the name tailspin-toys and create it in your own account. GitHub may also open a few starter issues in the new repository. You can ignore them.

2. Open your repository in the app

Tailspin Toys repository with the Code menu and Open the app option highlighted — Code → Local → Open the app. Use this menu on your new repository.

3. Allow the repository to be cloned

Clone repository confirmation dialog with the Allow button highlighted — Confirm your repository → Allow. Your own repository name appears in the dialog.

4. Find the repository in Sessions

App sidebar showing the repository under Sessions with No sessions yet — Sessions → your repository. The name in this screenshot may differ from yours.

5. Ask Copilot to run the app locally

Start a new session for your tailspin-toys repository. Check that Current checkout is selected, paste the prompt below and click the send arrow.

please run this app locally

Send the prompt → Copilot starts a session to run the app locally.

6. Explore the running app

Once Copilot confirms the app is running, open the local URL it provides (http://localhost:4321/ in this recording). Browse Featured Games, click View details on a game, then use Back to all games to return to the catalogue.

Open the local app → View details → Back to all games

Duration: 20 minutes

Acquire codebase knowledge

So what Turn an unfamiliar repository into an evidence-backed map you can use to plan better tests. The skill investigates the codebase, records what it can verify and flags what still needs an answer.

Awesome Copilot is a community library of guides, agents, skills and tools for GitHub Copilot. Today we use one of its skills to understand Tailspin Toys. Explore the library ↗

1Ask Copilot to onboard you with the skill

In your tailspin-toys session, copy this prompt into Copilot and send it:

onboard me to this repo with this skill https://awesome-copilot.github.com/skill/acquire-codebase-knowledge/

Paste the onboarding prompt with the skill link → Send

What the skill produces

One repository map. Seven documents in docs/codebase/.

What's it built with? STACK.md

Languages, runtimes, frameworks and dependencies.

Where does everything live? STRUCTURE.md

Folders, entry points and key files.

How does it fit together? ARCHITECTURE.md

Components, boundaries and data flow.

How is code written here? CONVENTIONS.md

Coding patterns and error handling.

What does it connect to? INTEGRATIONS.md

Databases, external services and configuration.

How is it tested? TESTING.md

Test tools, organisation and mocking patterns.

Where should we look next? CONCERNS.md

Evidence-backed risks, technical debt and coverage gaps — a starting point for our test planning.

[TODO] means unknown, not assumed.

2Review the generated codebase documents

Explore the generated documents in docs/codebase/.

Duration: 25 minutes

Find test gaps. Add meaningful coverage.

So what A passing test suite does not prove every important behaviour. Use the codebase map to find missing or weak tests, then turn one verified gap into a regression test.

1Meet the Test Gap Audit skill5 min

Open Test Gap Audit on Awesome Copilot ↗. This skill compares code paths with what existing tests actually assert. It stays read-only until you explicitly ask it to add tests.

1 Map the behaviour

Inspect source, existing tests and repository test conventions.

2 Rank the gaps

Prioritise by impact, with evidence and concrete test scenarios.

3 Prove the behaviour

Prefer meaningful assertions over a higher coverage percentage alone.

2Run a read-only audit of Tailspin Toys8 min

Copy this audit prompt into Copilot:

Audit this Tailspin Toys repository using this skill: https://awesome-copilot.github.com/skill/test-gap-audit/

Use docs/codebase/TESTING.md and docs/codebase/CONCERNS.md as context, then verify against the current code and tests. Inventory the repository's testable surfaces before inspecting the highest-risk areas. Use the skill's coverage mapping script if available, and verify its leads before calling them confirmed gaps.

Report prioritised P0-P3 findings with source and test file:line evidence, what the current tests prove, and specific proposed tests with key assertions. Separate confirmed gaps from inferred gaps. State surface counts, list areas surveyed but not deeply inspected, and record checks run or skipped. Do not change any files or add tests yet.

Read the report before acting. A file without a directly matching test may still be covered indirectly. If the audit cannot finish in this session, use its list of areas not deeply inspected for a follow-up pass.

3Generate a local HTML audit report2 min

Once the audit is complete, ask Copilot to turn the finalised findings into a simple local HTML page. Save the report outside the repository to keep the audited files unchanged, then open it in your browser.

Copy this report prompt into Copilot:

Please generate the finalised report in a simple local html page

Copilot session showing the request to generate the finalised test gap audit report in a simple local HTML page

Keep the priorities, source evidence and checks run or skipped visible in the report. Generating the report does not authorise implementing the suggested fixes or tests.

4Create GitHub issues for the P1 gaps10 min

Copy this prompt into Copilot:

Create a detailed github issue for each of the P1 gaps in this repository

The recording asks for two issues because that audit found two P1 gaps. Your audit may rank gaps differently, so create one issue per P1 gap in your report.

Repository Issues tab showing two published issues: the database-explorer SQL guard gap and missing seedDatabase unit tests — Example result: both P1 gaps are published as GitHub issues. Your titles will differ.

Duration: 10 minutes

From unfamiliar code to meaningful tests

The takeaway Understand first. Audit with evidence. Add tests that prove behaviour. Copilot helps investigate and implement. You review the evidence, choose the gap and check the results.

The loop you can reuse

Run Map Audit Choose Test Verify

Repeat for the next behaviour or area that needs deeper inspection.

Keep these resources

Tailspin Toys

Open the template ↗

Acquire Codebase Knowledge

Open the skill ↗

Test Gap Audit

Open the skill ↗

Try it in your own repository

Choose one unfamiliar area, map it, audit its tests and add one reviewed regression test. Keep the change focused, record the checks and share unresolved questions with your team.