A Quick Look GitHub Copilot

In this lesson/article we take a focused tour of GitHub Copilot inside Visual Studio Code and use it to scaffold a small Python project that reads and prints CSV data. Along the way we’ll demonstrate how Copilot helps you:

Scaffold a Python app with an argument parser (argparse)
Create mock CSV data for quick testing
Suggest edits to fix runtime errors from tracebacks
Generate simple unit tests and test configuration

This walkthrough uses a workspace folder named csvreader.

GitHub Copilot speeds up routine tasks by generating boilerplate (project scaffolds, argument parsing, tests) and proposing fixes based on error output. Always review generated code for correctness and security — Copilot helps you iterate faster, not replace review.

Project scaffold and virtual environment

Quick steps to create the project directory and a Python virtual environment:

mkdir csvreader
cd csvreader

python3 -m venv venv
source venv/bin/activate   # macOS / Linux
# On Windows PowerShell: .\venv\Scripts\Activate.ps1

A minimal app.py example Copilot might generate:

# app.py
def main():
    print("Hello, World!")

if __name__ == "__main__":
    main()

Install any runtime dependencies as needed and run the script:

pip install requests
python app.py

Quick reference — useful local commands:

Action	Command
Create venv	`python3 -m venv venv`
Activate venv (macOS/Linux)	`source venv/bin/activate`
Activate venv (Windows PowerShell)	`.\venv\Scripts\Activate.ps1`
Run script	`python main.py`

Scaffolding a main script with argparse

Copilot (inline suggestions or Copilot Chat) can quickly scaffold a main.py using argparse so your script accepts a CSV file path. A typical skeleton looks like:

import argparse

def main():
    parser = argparse.ArgumentParser(description="Your application description")
    # Add your arguments here
    args = parser.parse_args()

    # TODO: Implement your application logic
    print("Hello, World!")

if __name__ == "__main__":
    main()

Save the file and run it to confirm the script executes. If you see “unrecognized arguments,” Copilot can suggest missing parser.add_argument(...) lines when you paste the traceback into Copilot Chat.

Creating a mock CSV file

For quick testing create a mock CSV file (e.g., data.csv) with columns: first name, last name, IP address, city, state. Copilot can generate this for you if asked.

first name,last name,ip address,city,state
John,Doe,192.168.1.1,New York,NY
Jane,Smith,192.168.1.2,Los Angeles,CA
Bob,Johnson,192.168.1.3,Chicago,IL
Alice,Williams,192.168.1.4,Houston,TX
Michael,Brown,192.168.1.5,Phoenix,AZ

Reading a CSV file (initial approach)

Copilot often suggests a minimal read_csv implementation using readlines():

# main.py (initial readlines-based implementation)
def read_csv(file_path):
    with open(file_path, "r", encoding="utf-8") as file:
        data = file.readlines()
    return data

Connect this to the argument parser and print the file contents:

import argparse

def read_csv(file_path):
    with open(file_path, "r", encoding="utf-8") as file:
        data = file.readlines()
    return data

def main():
    parser = argparse.ArgumentParser(description="Your application description")
    parser.add_argument("csv_file", type=str, help="Path to the CSV file")
    args = parser.parse_args()

    csv_file = args.csv_file
    print(csv_file)

    data = read_csv(csv_file)
    for line in data:
        print(line.strip())

if __name__ == "__main__":
    main()

Run the script:

python main.py data.csv

If Copilot inserted the parser argument incorrectly (e.g., you get “unrecognized arguments”), paste the error message into Copilot Chat and accept the suggested parser.add_argument(...) edits directly in the editor.

Parsing fields and showing only first and last names

To print only first and last names and skip the header, update the loop to split lines and ignore the first row:

import argparse

def read_csv(file_path):
    with open(file_path, "r", encoding="utf-8") as file:
        data = file.readlines()
    return data

def main():
    parser = argparse.ArgumentParser(description="CSV reader that prints first and last names")
    parser.add_argument("csv_file", type=str, help="Path to the CSV file")
    args = parser.parse_args()

    csv_file = args.csv_file

    data = read_csv(csv_file)
    for i, line in enumerate(data):
        if i == 0:
            # Skip header row
            continue
        fields = line.strip().split(",")
        # Print first name and last name
        print(f"{fields[0]} {fields[1]}")

if __name__ == "__main__":
    main()

Running python main.py data.csv produces:

John Doe
Jane Smith
Bob Johnson
Alice Williams
Michael Brown

Callout: For production or complex CSVs prefer the standard library’s csv module, which handles quoting and embedded commas robustly.

Fixing errors with Copilot

A practical Copilot workflow:

Run the code and copy any traceback/trace output.
Paste the error into Copilot Chat.
Copilot will typically propose targeted fixes (e.g., add missing parser.add_argument, fix indexing issues, or handle file-not-found errors).
Review the proposed changes and apply them in your editor.

This iterative loop accelerates debugging while keeping you in control.

Generating tests

Copilot can scaffold tests and configure a test runner. In the demo, Copilot produced a test_main.py file using unittest style tests. You can convert these to pytest style if preferred. Example test_main.py:

# test_main.py
import os
import unittest
from main import read_csv

class TestReadCSV(unittest.TestCase):
    def setUp(self):
        # Create a temporary CSV file to use in tests
        self.test_csv_file = "test_temp.csv"
        with open(self.test_csv_file, "w", encoding="utf-8") as f:
            f.write("header1,header2\n")
            f.write("row1col1,row1col2\n")
            f.write("row2col1,row2col2\n")

    def tearDown(self):
        # Remove the temporary CSV file
        os.remove(self.test_csv_file)

    def test_read_csv(self):
        expected_data = [
            "header1,header2\n",
            "row1col1,row1col2\n",
            "row2col1,row2col2\n"
        ]
        actual_data = read_csv(self.test_csv_file)
        self.assertEqual(actual_data, expected_data)

    def test_read_csv_empty_file(self):
        # Create an empty CSV file
        empty_csv_file = "empty_test.csv"
        with open(empty_csv_file, "w", encoding="utf-8") as f:
            pass

        expected_data = []
        actual_data = read_csv(empty_csv_file)
        self.assertEqual(actual_data, expected_data)

        os.remove(empty_csv_file)

    def test_read_csv_single_line(self):
        single_line_csv_file = "single_line_test.csv"
        with open(single_line_csv_file, "w", encoding="utf-8") as f:
            f.write("header1,header2\n")

        expected_data = ["header1,header2\n"]
        actual_data = read_csv(single_line_csv_file)
        self.assertEqual(actual_data, expected_data)

        os.remove(single_line_csv_file)

if __name__ == "__main__":
    unittest.main()

Run the test suite:

python -m pytest

Example pytest output when tests pass:

collected 3 items

test_main.py ...
============================== 3 passed in 0.00s ==============================

If you intentionally change expected values to force a failure, the pytest trace will show differing elements — Copilot can help interpret the output and suggest fixes or improved assertions.

Adding docstrings and comments

Copilot can generate docstrings and inline comments. Select a function and ask Copilot to document it — it will insert a docstring describing the function’s purpose, parameters, and return values. Use generated docs as a starting point and refine them to match your code’s intent.

Summary

GitHub Copilot in Visual Studio Code is handy for:

Scaffolding applications and argparse usage
Generating test scaffolding and basic unit tests
Producing mock data files for development and tests
Suggesting quick fixes based on error messages and tracebacks
Drafting comments and docstrings

Copilot accelerates routine development tasks, but always review generated code for correctness, performance, and security. For reliable CSV parsing in production, prefer the built-in csv module or a vetted third-party library. Next in the course: we’ll look at Cursor AI, an IDE built on Visual Studio Code.

Course Introduction

Introduction to AI-Assisted Development

Planning Phase

Development Phase - Backend

Development Phase - Frontend

Project Completion

A Quick Look GitHub Copilot

Project scaffold and virtual environment

Scaffolding a main script with argparse

Creating a mock CSV file

Reading a CSV file (initial approach)

Parsing fields and showing only first and last names

Fixing errors with Copilot

Generating tests

Adding docstrings and comments

Summary

Links and References

Watch Video

​Project scaffold and virtual environment

​Scaffolding a main script with argparse

​Creating a mock CSV file

​Reading a CSV file (initial approach)

​Parsing fields and showing only first and last names

​Fixing errors with Copilot

​Generating tests

​Adding docstrings and comments

​Summary

​Links and References

Watch Video

Project scaffold and virtual environment

Scaffolding a main script with argparse

Creating a mock CSV file

Reading a CSV file (initial approach)

Parsing fields and showing only first and last names

Fixing errors with Copilot

Generating tests

Adding docstrings and comments

Summary

Links and References