About • Learning Objectives • Modules • Labs • Resources

📚 Course 1 of the GitHub Copilot Mastery Pathway ⏱️ Duration: ~60 minutes

Welcome to "Advanced Prompting with GitHub Copilot"! This course is the first in the GitHub Copilot Mastery Pathway, designed to elevate your GitHub Copilot skills from basic completions to advanced conversational interactions. You'll learn how to craft effective multi-turn prompts, refine your requests iteratively, and work with complex codebases across multiple files. By mastering these techniques, you'll dramatically improve your productivity and code quality.

By the end of this course, you will be able to:

• ✅ Transition from basic autocomplete to conversational interactions with GitHub Copilot
• ✅ Understand and leverage different chat input methods and modes
• ✅ Craft effective multi-turn prompts for complex coding tasks
• ✅ Apply iterative refinement techniques to improve code quality
• ✅ Provide context from multiple files to enhance Copilot's accuracy
• ✅ Leverage open files strategically for better code suggestions
• ✅ Generate implementation code from API documentation
• ✅ Navigate and understand unfamiliar codebases efficiently

• Introduction to the course and learning pathway
• Transitioning from basic to conversational AI
• Understanding the power of multi-turn interactions
• Overview of chat inputs and interaction methods
• Overview of chat modes (inline, chat, and editor)

• 💬 Crafting effective multi-turn prompts
• 🔄 Iterative refinement techniques for code improvement
• 🎯 Challenge: Refactor with conversation
• ✅ Solution: Refactor with conversation
• 📊 Analyzing your conversational approach

• 📂 Providing context from multiple files
• 🎯 Leveraging open files for accuracy
• 🎯 Challenge: Generate code from API docs
• ✅ Solution: Generate code from API docs
• 🔍 Working with unknown codebases

This course includes hands-on labs organized by module to reinforce your learning. Each lab provides practical experience with the concepts covered in the videos.

• Lab 1: Getting Started with Conversational Prompting
• Lab 2: Mastering Multi-Turn Interactions

• Lab 3: Iterative Refinement Practice

• Lab 4: Multi-File Context Management
• Lab 5: Documentation Generation and Code Creation
• Lab 6: Exploring Unknown Codebases

• Bonus 1: Python to Rust CLI Conversion - 🦀 Use AI to transpile Python argparse scripts to Rust
• Bonus 2: Customizing PMAT Test Generation - 🎨 Override default prompts for language-specific test goals

This repository includes a complete working example demonstrating Python-to-Rust CLI conversion:

📂 Python to Rust CLI Example - A fully functional greeter CLI with:

• 🐍 Python implementation using argparse
• 🦀 Rust implementation using clap
• ✅ Comprehensive test suites for both versions
• 🔄 I/O equivalence validation tests
• ⚡ Performance comparison

Run the example:

# Build and test
make example-test

# Just build
make example-build

To get the most out of this course, we recommend practicing your prompting skills on these well-structured open-source repositories:

• Flask - A lightweight WSGI web application framework
• Jinja - A modern and designer-friendly templating language

• Express - Fast, unopinionated, minimalist web framework
• Lodash - A modern JavaScript utility library

• Ruby on Rails - A web application framework in Ruby

• Reprorusted Python CLI - 🦀 Python to Rust transpilation examples with performance benchmarks
• PMAT Agent Toolkit - 🤖 AI-powered test generation and quality tools

These repositories are ideal for practicing because they:

• ✅ Have clear code structure and organization
• ✅ Include comprehensive documentation
• ✅ Feature multiple interconnected files
• ✅ Represent real-world production codebases
• ✅ Have active communities and good examples

Before starting the labs, ensure you have:

1. 🤖 GitHub Copilot Access: An active GitHub Copilot subscription (individual, business, or enterprise)
2. 💻 IDE Setup: Visual Studio Code or a JetBrains IDE with GitHub Copilot extension installed
3. 📦 Git: Installed and configured on your system
4. 🔧 Programming Language Support: At least one of Python, JavaScript/TypeScript, Java, or Ruby installed

1. Clone this repository:

   git clone https://github.com/paiml/advanced-prompting-with-github-copilot
   cd advanced-prompting-with-github-copilot

2. Install dependencies:

   make install

3. Run tests to verify setup:

   make test

4. Optional: Clone practice repositories:

   git clone https://github.com/pallets/flask
   cd flask

This course focuses on using GitHub Copilot with Visual Studio Code. You may use other text editors but note that there might be slight differences in features.

1. Start with Module 1 labs in labs/module1/
2. Open the repository in your IDE with GitHub Copilot enabled
3. Follow along with video content and complete hands-on exercises
4. Practice on recommended repositories to reinforce learning
5. Complete bonus exercises for advanced applications

Build and test the Python-to-Rust CLI example:

# Run all tests (Python, Rust, and I/O equivalence)
make example-test

# Just build the Rust binary
make example-build

# Clean build artifacts
make example-clean

make help           # Show all available commands
make install        # Install all dependencies
make lint           # Run all linting
make test           # Run all tests
make validate       # Validate repository structure
make example-test   # Test the working example

Use the following tools and resources to enhance your experience when working with this course:

• GitHub Copilot Documentation
• GitHub Copilot Chat
• GitHub Copilot in VS Code
• JetBrains GitHub Copilot Plugin
• Pragmatic AI Labs

This course is Course 1 in a 4-course series:

1. 📚 Advanced Prompting with GitHub Copilot (this course) - Repository
2. 🔧 GitHub Copilot for System-Level Development - Repository
3. 🛡️ Responsible AI Development with GitHub Copilot - Repository
4. 🏆 Capstone: Building Production Features with Copilot - Repository

• 🎯 Be Specific: The more context you provide, the better Copilot's suggestions
• 🔄 Iterate Often: Don't expect perfection on the first try - refine your prompts
• 📂 Keep Files Open: Copilot uses open files as context - leverage this strategically
• 💬 Use Comments: Write clear comments to guide Copilot's understanding
• ✅ Review Suggestions: Always review and test Copilot's code before accepting
• 🧪 Experiment: Try different prompting approaches to find what works best

We welcome contributions to improve this course! Here's how you can help:

• 🐛 Report Issues: Found a bug or broken link? Open an issue
• 💡 Suggest Improvements: Have ideas for new labs or content? Share them!
• 📝 Fix Documentation: Improve clarity, fix typos, or add examples
• ✨ Add Examples: Contribute additional working examples or exercises
• 🧪 Improve Tests: Enhance test coverage or add new test cases

1. Fork the repository on GitHub
2. Clone your fork locally:

   git clone https://github.com/YOUR_USERNAME/advanced-prompting-with-github-copilot
   cd advanced-prompting-with-github-copilot

3. Create a feature branch:

   git checkout -b feature/your-feature-name

4. Make your changes and ensure tests pass:

   make test

5. Commit your changes with a clear message:

   git commit -m "Add feature: your feature description"

6. Push to your fork:

   git push origin feature/your-feature-name

7. Open a Pull Request on GitHub

All contributions must meet these standards:

• ✅ Pass all linting checks (make lint)
• ✅ Pass all tests (make test)
• ✅ Include documentation for new features
• ✅ Follow existing code style and patterns
• ✅ Update CLAUDE.md if repository structure changes

Copyright © 2025 Pragmatic AI Labs

This course material is provided for educational purposes. All rights reserved.

For licensing inquiries, contact Pragmatic AI Labs.

Made with ❤️ by Pragmatic AI Labs