Week 3 - Prompt Engineering & Productivity : Copilot Free learning & cert prep

[Akash1134]

👋 Welcome to Week 3 of the GitHub Copilot Free learning journey and cert prep! We're now at the halfway point in our learning journey, and it’s been incredible to see the depth of thought and creativity in your submissions so far.

This week, we’re shifting our focus to some of the core principles of prompt engineering and productivity. Understanding these foundational concepts will help you craft more effective prompts, allowing you to harness Copilot’s full potential for smarter, faster coding. Here's what we'll be covering to refine your skills and take your workflow to the next level 🚀

• Prompt Crating and Prompt Engineering
  • Fundamentals of prompt crafting
  • Fundamentals of prompt engineering
• Developer use cases for AI
  • Improve developer productivity
  • How GitHub Copilot can help with SDLC
  • Limitations of using GitHub Copilot
  • How to use the productivity API to see how GitHub Copilot impacts coding

Note

Don’t miss out—Keep engaging, learning, and growing together! Top participants will earn a GitHub Certifications exam voucher! 🎫 Think of it as your golden ticket to advancing your career! 💼

Your First Move: Study Smart, Level Up! 🎯

We've already explored Copilot’s features and data handling, giving you a solid foundation in how it works. Now, it's time to take your skills to the next level by mastering the art of prompt creation and prompt engineering. The way you frame your inputs directly impacts the quality of AI-generated outputs, and learning how to craft effective prompts will help you get the most out of Copilot. We'll also dive into real-world developer use cases, showing you practical ways Copilot can streamline your workflow, boost productivity, and enhance your coding experience.

• Microsoft Learn Modules (each of the modules has its own knowledge check exercise)
  • Introduction to prompt engineering with GitHub Copilot
  • Developer use cases for AI with GitHub Copilot
    • Using GitHub Copilot with JavaScript (Optional)
    • Using GitHub Copilot with Python (Optional)
  • Implement code improvements using GitHub Copilot tools
  • Develop code features using GitHub Copilot tools
• GitHub Learning Pathways
  • Essentials of GitHub Copilot (series)
• 🤩 Microsoft Ignite 2024 (Bonus)
  • Maximize developer efficiency with GitHub Copilot for partner success
  • Top 5 GitHub Copilot Features at Microsoft Ignite 2024
  • Discover GitHub Copilot's untapped potential in Visual Studio
  • GitHub Copilot's Game Changing Features
• Videos
  • Master the core principles of prompt engineering with GitHub Copilot
  • Visual Studio Prompt Engineering with GitHub Copilot
  • GitHub Copilot Study Guide Series 2: Developer use cases for AI with GitHub Copilot
  • Level up with GitHub Copilot: using AI to learn, code, and build
  • Getting started with GitHub Copilot (Playlist with over 80 videos)
• Blogs and Resources
  • Research: quantifying GitHub Copilot’s impact on developer productivity and happiness
  • What’s a prompt and what is prompt engineering?
  • What are the pros and cons of using GitHub Copilot?
  • How to use GitHub Copilot: Prompts, tips, and use cases
• GitHub Docs
  • Prompt engineering for GitHub Copilot
  • Use GitHub Copilot
  • Manage GitHub Copilot

Knowledge Checkpoint 🏁 - Let’s See What You’ve Got! 🧠

1. When using GitHub Copilot in a corporate environment, which of the following practices could introduce legal or security risks? (Select two)

A) Using Copilot to generate code for encryption algorithms without verification.
B) Enabling Copilot to suggest code completions within a private enterprise repository.
C) Accepting Copilot-generated code that lacks licensing information.
D) Using Copilot in an IDE that does not support secure API calls.

2. A developer is working with Copilot in Visual Studio and wants to optimize Copilot’s inline chat for debugging. What is the best way to achieve this?

A) Rewriting prompts to be more detailed, explicitly mentioning expected outputs.
B) Running Copilot Chat multiple times to get varied debugging suggestions.
C) Adjusting Copilot’s temperature parameter to control randomness in responses.
D) Restricting Copilot Chat to only use file-specific context rather than project-wide scope.

3. A developer is using GitHub Copilot to generate a function for sorting a large dataset (100,000+ entries). Copilot suggests the following function:

python
Copy
Edit
def sort_data(data):
    return sorted(data)

Why might this function be suboptimal for large datasets?
A) The sorted() function is not efficient for large datasets.
B) The function lacks an explicit sorting algorithm, making it unpredictable.
C) The function does not use an in-place sorting method like data.sort().
D) Copilot might suggest a less efficient sorting algorithm if not prompted explicitly.

4. A developer asks Copilot to generate a function that computes Fibonacci numbers. The suggested function uses recursion but lacks memoization. What is the most likely reason for this omission?

A) Copilot prioritizes standard implementations seen in open-source projects.
B) Copilot avoids generating computationally expensive algorithms.
C) Copilot lacks context about performance optimizations unless explicitly prompted.
D) Copilot assumes the user will manually optimize the generated code.

5. When using GitHub Copilot for SQL query generation, what should developers be cautious about?

A) Copilot always generates the most optimized query.
B) Copilot might suggest queries vulnerable to SQL injection.
C) Copilot does not support SQL query generation.
D) Copilot automatically optimizes database indexes.

6. A team is using Copilot for collaborative development. Developer A enables Copilot in a private repository. Developer B, working in the same repository, notices Copilot's suggestions contain code snippets that look unfamiliar. What might be happening?

A) Copilot is retrieving suggestions from similar open-source projects.
B) Copilot is generating code based on patterns detected in the project’s existing files.
C) Copilot is using external AI models to fetch relevant public code snippets.
D) Copilot is applying prompt engineering techniques to infer missing logic.

7. You request Copilot to generate a SQL query but notice that the suggested query lacks proper indexing considerations. What should you do?

A) Add a comment specifying performance constraints and indexing requirements.
B) Re-prompt Copilot with a more detailed query request.
C) Accept the query and manually optimize it.
D) Adjust Copilot’s model settings to prioritize efficiency.

8. A developer needs Copilot to generate optimized SQL queries. What prompt will yield the best results?

A) # Generate an SQL query to retrieve customer data.
B) # Write an optimized SQL query that retrieves customer data using an index on customer_id.
C) # Write an SQL query for fetching customer data using JOINs.
D) # Generate a basic SQL query to fetch all rows from the customers table.

9. A team is developing a proprietary algorithm and wants to ensure Copilot does not suggest code similar to public implementations. What is the best approach? (Select two)

A) Use private repositories with Copilot to limit exposure to public code patterns.
B) Explicitly describe unique constraints and design principles in inline comments.
C) Turn off Copilot suggestions for functions that contain proprietary logic.
D) Modify Copilot's training dataset to exclude certain open-source projects.

10. According to research on GitHub Copilot's impact, which of the following factors contribute most significantly to increased developer productivity when using Copilot? (Select two correct answers)

A) Reduction in the time spent searching for solutions on external websites.
B) Increased number of lines of code written per hour.
C) A higher frequency of completed pull requests per developer.
D) Faster onboarding of new developers due to AI-assisted code understanding.

11. Which of the following factors most significantly influence GitHub Copilot’s ability to generate high-quality completions? (Select two)

A) The recency of the training data used to build the model.
B) The user's coding patterns and past accepted suggestions.
C) The number of times the user has prompted Copilot in a single session.
D) Whether the user is working in an IDE or a browser-based editor.

12. You are using GitHub Copilot in Visual Studio Code and notice that it frequently suggests outdated API methods that have been deprecated. What are the most effective strategies to improve the relevance of suggestions? (Select two)

A) Add a comment explicitly mentioning the latest API version before the function definition.
B) Use natural language prompts that describe the intent of the code rather than function names.
C) Adjust the settings to restrict Copilot to suggestions from private repositories only.
D) Revert to an older version of GitHub Copilot that was trained on previous API versions.

13. A developer is building a machine learning model in Python. They ask GitHub Copilot to generate a function for model training but notice that Copilot repeatedly suggests suboptimal hyperparameter choices. What is the best way to guide Copilot to generate better completions?

A) Use inline comments to specify preferred hyperparameters and model architectures.
B) Accept a Copilot suggestion and manually tweak the parameters later.
C) Change the function name to include terms like “optimized” or “efficient.”
D) Train Copilot on previous successful models to improve its suggestions.

🚀 🚀 🚀

[paulsuv9]

Lets go! 🚀 🚀 🚀

[Ronaldo-001]

Lezzz go!!

[hemanthnutakki]

Lezzzz goo!!!!!

[hemanthnutakki]

I'm very excited. By understanding developer use cases, AI-driven productivity boosts, and Copilot’s role in SDLC, we can refine our workflows and make the most of its capabilities. We'll also explore Copilot’s limitations and how to leverage the productivity API to measure its impact.

[paulsuv9]

Great enthusiasm! I found that adding specific constraints in the prompt really helps Copilot generate more accurate code. How do you usually refine your prompts? 👍

[johnniekpng]

Go go go...

[Ronaldo-001]

This week was so nice and dug a lot into developer use cases for AI.

Here are my answers for this week:

1. When using GitHub Copilot in a corporate environment, which of the following practices could introduce legal or security risks? (Select two)

• ✅ A) Using Copilot to generate code for encryption algorithms without verification.
• ❌ B) Using Copilot-generated comments to explain complex logic.
• ✅ C) Accepting Copilot-generated code that lacks licensing information.
• ❌ D) Using Copilot to generate documentation for internal APIs.

Explanation:

Copilot-generated encryption algorithms might not be secure or follow industry best practices, leading to security vulnerabilities. Copilot can generate code without proper licensing information, leading to potential legal and intellectual property issues.

---

2. A developer is working with Copilot in Visual Studio and wants to optimize Copilot’s inline chat for debugging. What is the best way to achieve this?

• ✅ A) Rewriting prompts to be more detailed, explicitly mentioning expected outputs.
• ❌ B) Running Copilot in an isolated environment.
• ❌ C) Disabling Copilot's suggestions to avoid incorrect results.
• ❌ D) Avoiding Copilot's inline chat altogether for debugging.

Explanation:

Providing more detailed prompts helps Copilot generate more relevant debugging suggestions.

---

3. A developer is using GitHub Copilot to generate a function for sorting a large dataset (100,000+ entries). Why might this function be suboptimal for large datasets?

def sort_data(data):
    return sorted(data)

• ❌ A) The function uses Python’s built-in sorted() function.
• ❌ B) The function lacks proper error handling.
• ✅ C) The function does not use an in-place sorting method like data.sort().
• ❌ D) The function does not implement a custom sorting algorithm.

Explanation:

sorted(data)creates a new sorted list, increasing memory usage. Usingdata.sort()` sorts the list in place, reducing overhead.

---

4. A developer asks Copilot to generate a function that computes Fibonacci numbers. The suggested function uses recursion but lacks memoization. What is the most likely reason for this omission?

• ❌ A) Copilot avoids recursion in general.
• ❌ B) Copilot assumes performance optimizations are unnecessary.
• ✅ C) Copilot lacks context about performance optimizations unless explicitly prompted.
• ❌ D) Copilot generates inefficient code by default.

Explanation:

Copilot generates code based on common patterns, and unless explicitly prompted, it might not consider optimizations like memoization.

---

5. When using GitHub Copilot for SQL query generation, what should developers be cautious about?

• ❌ A) Copilot might use incorrect SQL syntax.
• ✅ B) Copilot might suggest queries vulnerable to SQL injection.
• ❌ C) Copilot does not support SQL queries.
• ❌ D) Copilot always ensures optimized query performance.

Explanation:

Copilot-generated SQL queries may not use parameterized queries, making them vulnerable to SQL injection.

---

6. A team is using Copilot for collaborative development. Developer A enables Copilot in a private repository. Developer B, working in the same repository, notices Copilot's suggestions contain code snippets that look unfamiliar. What might be happening?

• ❌ A) Copilot is pulling suggestions from external repositories.
• ✅ B) Copilot is generating code based on patterns detected in the project’s existing files.
• ❌ C) Copilot is accessing developer B’s personal GitHub repositories.
• ❌ D) Copilot is using AI-generated randomness.

Explanation:

Copilot suggests code based on the project’s context, including existing files in the repository.

---

7. You request Copilot to generate a SQL query but notice that the suggested query lacks proper indexing considerations. What should you do?

• ✅ A) Add a comment specifying performance constraints and indexing requirements.
• ❌ B) Disable Copilot’s SQL suggestions.
• ❌ C) Accept the generated query and optimize it later.
• ❌ D) Rely on Copilot to always generate optimized queries.

Explanation:

Explicitly defining performance needs in comments improves Copilot’s suggestions.

---

8. A developer needs Copilot to generate optimized SQL queries. What prompt will yield the best results?

• ❌ A) # Write a SQL query to fetch data.
• ✅ B) # Write an optimized SQL query that retrieves customer data using an index on customer_id.
• ❌ C) # Fetch customer data.
• ❌ D) # Generate a basic SQL query.

Explanation:

Providing specific requirements like "optimized" and "using an index on customer_id" ensures Copilot generates a more efficient query.

---

9. A team is developing a proprietary algorithm and wants to ensure Copilot does not suggest code similar to public implementations. What is the best approach? (Select two)

• ✅ A) Use private repositories with Copilot to limit exposure to public code patterns.
• ✅ B) Explicitly describe unique constraints and design principles in inline comments.
• ❌ C) Avoid using Copilot for proprietary code.
• ❌ D) Rely on Copilot’s built-in safeguards.

Explanation:

Private repositories prevent Copilot from using public code patterns in suggestions and providing unique constraints helps Copilot generate more original code.

---

10. According to research on GitHub Copilot's impact, which of the following factors contribute most significantly to increased developer productivity when using Copilot? (Select two)

• ✅ A) Reduction in the time spent searching for solutions on external websites.
• ❌ B) Copilot’s ability to replace all manual coding.
• ❌ C) Copilot’s ability to generate perfect code without human review.
• ✅ D) Faster onboarding of new developers due to AI-assisted code understanding.

Explanation:

Copilot reduces the need to search for external resources, speeding up development.
New developers onboard faster as Copilot assists in understanding and writing code.

---

11. Which of the following factors most significantly influence GitHub Copilot’s ability to generate high-quality completions? (Select two)

• ✅ A) The recency of the training data used to build the model.
• ✅ B) The user's coding patterns and past accepted suggestions.
• ❌ C) Copilot’s randomness.
• ❌ D) The number of programming languages Copilot supports.

Explanation:

More recent training data ensures Copilot generates relevant and up-to-date suggestions.
Copilot learns from user interactions, improving based on accepted completions.

---

12. You are using GitHub Copilot in Visual Studio Code and notice that it frequently suggests outdated API methods that have been deprecated. What are the most effective strategies to improve the relevance of suggestions? (Select two)

• ✅ A) Add a comment explicitly mentioning the latest API version before the function definition.
• ✅ B) Use natural language prompts that describe the intent of the code rather than function names.
• ❌ C) Disable Copilot and write the code manually.
• ❌ D) Ignore the suggestions and try again.

Explanation:

Mentioning the latest API version in comments helps Copilot generate up-to-date suggestions.
Describing the intent ensures Copilot understands the context better and suggests modern alternatives.

---

Also, This week resources are so good ! Thanks @Akash1134 for providing these resources!
Finally excited to share my project soon, which was built with the help of GitHub Copilot.

[paulsuv9]

Thanks for sharing your answers, @Ronaldo-001! Your detailed explanations are very insightful.

[SatyamSharma007]

Question: When using GitHub Copilot in a corporate environment, which of the following practices could introduce legal or security risks? (Select two)

✅ A) Using Copilot to generate code for encryption algorithms without verification.

✅ C) Accepting Copilot-generated code that lacks licensing information.

Question: A developer is working with Copilot in Visual Studio and wants to optimize Copilot’s inline chat for debugging. What is the best way to achieve this?

✅ A) Rewriting prompts to be more detailed, explicitly mentioning expected outputs.

Question: A developer is using GitHub Copilot to generate a function for sorting a large dataset (100,000+ entries). Why might this function be suboptimal for large datasets?

✅ C) The function does not use an in-place sorting method like data.sort().

Question: A developer asks Copilot to generate a function that computes Fibonacci numbers. The suggested function uses recursion but lacks memoization. What is the most likely reason for this omission?

✅ C) Copilot lacks context about performance optimizations unless explicitly prompted.

Question: When using GitHub Copilot for SQL query generation, what should developers be cautious about?

✅ B) Copilot might suggest queries vulnerable to SQL injection.

Question: A team is using Copilot for collaborative development. Developer A enables Copilot in a private repository. Developer B, working in the same repository, notices Copilot's suggestions contain code snippets that look unfamiliar. What might be happening?

✅ B) Copilot is generating code based on patterns detected in the project’s existing files.

Question: You request Copilot to generate a SQL query but notice that the suggested query lacks proper indexing considerations. What should you do?

✅ A) Add a comment specifying performance constraints and indexing requirements.

Question: A developer needs Copilot to generate optimized SQL queries. What prompt will yield the best results?

✅ B) # Write an optimized SQL query that retrieves customer data using an index on customer_id.

Question: A team is developing a proprietary algorithm and wants to ensure Copilot does not suggest code similar to public implementations. What is the best approach? (Select two)

✅ A) Use private repositories with Copilot to limit exposure to public code patterns.

✅ B) Explicitly describe unique constraints and design principles in inline comments.

Question: According to research on GitHub Copilot's impact, which of the following factors contribute most significantly to increased developer productivity when using Copilot? (Select two)

✅ A) Reduction in the time spent searching for solutions on external websites.

✅ D) Faster onboarding of new developers due to AI-assisted code understanding.

Question: Which of the following factors most significantly influence GitHub Copilot’s ability to generate high-quality completions? (Select two)

✅ A) The recency of the training data used to build the model.

✅ B) The user's coding patterns and past accepted suggestions.

Question: You are using GitHub Copilot in Visual Studio Code and notice that it frequently suggests outdated API methods that have been deprecated. What are the most effective strategies to improve the relevance of suggestions? (Select two)

✅ A) Add a comment explicitly mentioning the latest API version before the function definition.

✅ B) Use natural language prompts that describe the intent of the code rather than function names.

Question: A developer is building a machine learning model in Python. They ask GitHub Copilot to generate a function for model training but notice that Copilot repeatedly suggests suboptimal hyperparameter choices. What is the best way to guide Copilot to generate better completions?

✅ A) Use inline comments to specify preferred hyperparameters and model architectures.

[paulsuv9]

Great answers! I agree with your points. What do you think are the biggest challenges when using Copilot for large-scale projects? 🚀

[hemanthnutakki]

Great answers!!! I to agree with your points. The way of explanation is too good.

[kalharatennakoon]

Hey @Akash1134 👋
Here are my answers:

1. A & C
2. A
3. C
4. C
5. B
6. B
7. A
8. B
9. A & B
10. A & D
11. A & B
12. A & B
13. A

[paulsuv9]

Nice work! One tip I found useful this week is to use natural language prompts that describe the intent of the code rather than specific function names. It helps Copilot understand the context better. 👍

[Akash1134]

Join the Prompt battle 🤜

💡 Challenge:

Think you can out-prompt GitHub Copilot? Let’s put your prompt engineering skills to the test! Pick a simple coding task and refine your prompt step by step to get the best possible output from Copilot.

How to Participate:

1. Choose a simple task (e.g., "Write a function to reverse a string").
2. Start with a basic prompt and share Copilot's first response.
3. Refine your prompt to make Copilot’s response more efficient, readable, or creative—share the improvements!
4. Bonus: Engage with another participant’s attempt --> can you suggest an even better prompt?

The best one wins the battle ✌️

Example:

• ❌ Basic prompt: "Reverse a string in Python." → Copilot gives a simple function.
• ✅ Improved prompt: "Write a Python function to reverse a string using recursion, with docstrings and edge case handling." → Copilot generates a more optimized version!

Share your Promptness below👇 (we have time till Monday next week)

[paulsuv9]

Great job on your initial prompt, @mvpkenlin! I have a refined version that might help you get even better results:

Contextual Prompt: “You are an expert in C#. Write a C# function to calculate the factorial of a number using recursion. Ensure the function handles edge cases and includes XML documentation comments.”

I chose this prompt because it provides a clear context and specifies the use of recursion and XML documentation comments, which are important for clarity and maintainability. This should help GitHub Copilot generate more accurate and optimized code.

What do you think? Have you tried using XML documentation comments before? 🚀

[Ronaldo-001]

Task: Write a Go program that concurrently fetches multiple URLs and prints their response times.

Basic Prompt:

"Write a Go program that fetches multiple URLs concurrently and prints their response times."

➡️ Copilot's First Output:

• A simple program using goroutines and http.Get() to fetch URLs concurrently.
• Prints response times but lacks optimizations like timeouts or error handling.

---

Refined Prompt (More Efficient and Robust):

"Write a Go program that concurrently fetches multiple URLs and prints their response times. Use goroutines, a worker pool pattern for efficiency, and context.WithTimeout() to handle slow requests. Ensure proper error handling and display results in a well-formatted table."

➡️ Copilot’s Improved Output:

Worker pool to limit concurrency instead of launching infinite goroutines.
Implements context.WithTimeout() to prevent hanging requests.
Includes error handling for failed requests.
Formats output using text/tabwriter for better readability.

---

Even Better Prompt (More Performance & Readability Enhancements):

"Write an optimized Go program that concurrently fetches multiple URLs and prints their response times. Implement a worker pool to limit concurrency, use context.WithTimeout() for handling slow requests, and measure response times precisely using time.Since(). Ensure detailed error handling and print results in a tabular format with headers using text/tabwriter. Additionally, sort the output by response time."

➡️ Final Copilot Output:

🔥 Adds precise timing using time.Since().
🔥 Sorts results by fastest to slowest responses.
🔥 Uses sync.WaitGroup to ensure all goroutines complete before printing results.

---

🎯 Result:

This step-by-step refinement leads to a more performant, readable, and robust Go program.

📌 Key Takeaways

Default AI Response ≠ Best Solution

• The first response lacks optimization and robustness.

Context Matters

• Adding "Use a worker pool and timeouts" improved the response quality.

Optimization Needs Explicit Prompting

• Without specifying timeouts, sorting, and structured output, Copilot didn’t consider them.

💡 Final Lesson:
AI prioritizes common solutions unless explicitly asked for the most optimal, efficient, and structured approach.

This challenge was so fun !! Learnt a lot about how to prompt effectively!

[johnniekpng]

Initial prompt: Write a python program to compare two dates difference in number of weeks
Result: Support only ISO date format YYYY-MM-DD

Refined prompt: Write a python program to compare two dates difference in number of weeks and need to handle different date formats
Result: Multiple Date Format Support:
ISO format (YYYY-MM-DD)
US format (MM/DD/YYYY)
European format (DD/MM/YYYY)
Various separators (-, /, .)

[johnniekpng]

@mvpkenlin Good job. I found that multiple approaches to factorial calculation are generated by Claude 3.7 Sonnet Thinking:

• Iterative method for better performance
• Recursive method for educational purposes
• BigInteger versions for handling very large numbers

[kareem1207]

Basic Prompt:
"develop a simple todo app in python with ui"
▶️Copilot's First Output:
• A simple setup in python.
• A basic ui todo program in python.

the 1st prompt results : kareem1207/Prompt-battle at first-prompt

---

Refined Prompt (More Efficient and Robust):
"improve ui , add time stamp , and also add priority level"
▶️ Copilot’s Improved Output:
Github Copilot handled the incoming errors and add the good ui.

1. Features added by github copilot :
   Enhanced UI with a larger window (600x600) and better organized layout
2. New features added:

1. Priority levels (High, Medium, Low) with color coding
2. Timestamps showing when each task was created
3. A proper table view using Treeview instead of a simple listbox
4. Color-coded tasks (red for high priority, orange for medium, green for low)

The 2nd prompt results : kareem1207/Prompt-battle at second-prompt

---

Even Better Prompt (More Performance & Readability Enhancements):
update my current python app with the following features :

1. increase the ui with the help of modern libraries
2. Better error handeloing
3. Increase the performance
4. Optimize the code
5. Deploy it in the github, it is already initalized with the github
   ▶️ Final Copilot Output:
6. Modern UI improvements:
   o Added ttkbootstrap for a modern look and feel
   o Implemented color-coded priorities
   o Enhanced UI layout and styling
7. Better error handling:
   o Added comprehensive try-except blocks
   o Implemented user-friendly error messages
   o Added detailed logging to todo_app.log
8. Performance optimizations:
   o Implemented background saving using threading
   o Added LRU caching for sorting operations
   o Optimized file operations
9. Code organization and deployment:
   o Created requirements.txt or dependency management
   o Added comprehensive README.md
   o Set up proper .gitignore
   o All changes are now tracked in version control

The final prompt results : kareem1207/Prompt-battle

---

🎯 Result:
This step-by-step refinement leads to a more performant, readable, and robust Go program.
📌 Key Takeaways
Default AI Response ≠ Best Solution
• The first response lacks optimization, ui and features.
Context Matters
• Adding the features list and the places where it need to improve make the output to be very well better.
Optimization Needs Explicit Prompting
• Without specifying the required features, Copilot didn’t consider them.
💡 Final Lesson:
AI prioritizes common solutions unless explicitly asked for the most optimal, efficient, structure and the required features approach.
This challenge was so fun!! Learnt a lot about how to prompt effectively! And sorry for late response.
Thanks @Akash1134 for giving this oppurtunity.

[Sirius-ashwak]

Here are my answers! @Akash1134

1. A & C
2. A
3. C
4. C
5. B
6. A
7. A
8. B
9. A & B
10. A & D
11. A & B
12. A & B
13. A

[paulsuv9]

I’m very excited about this week’s focus on prompt engineering! One tip I found useful is to be very specific with prompts to get the best results from Copilot. Has anyone else noticed a significant improvement in their code quality? 🚀

[paulsuv9]

It might be helpful to add a section on common pitfalls to avoid when using Copilot for prompt engineering.

[hemanthnutakki]

Absolutely! Being specific with prompts makes a huge difference. I've noticed that adding details like expected output format and constraints leads to much better responses from Copilot. It’s like giving clear instructions to a teammate! 🚀🔥

[hemanthnutakki]

Hey @Akash1134
Here are my week 3 answers:
A & C
A
C
C
B
B
A
B
A & B
A & D
A & B
A & B
A

[hemanthnutakki]

Absolutely @paulsuv9 ! Being specific with prompts makes a huge difference. I've noticed that adding details like expected output format and constraints leads to much better responses from Copilot. It’s like giving clear instructions to a teammate! 🚀🔥

[paulsuv9]

Absolutely, @hemanthnutakki! I’ve also noticed that adding constraints like expected output format significantly improves the quality of Copilot’s suggestions. Have you tried using it for complex algorithms?

[RAVINDRA8008]

Week 3 is looking exciting! 🚀 Prompt engineering is a crucial skill for getting the most out of GitHub Copilot, and it’s great to see a focus on developer productivity and real-world AI use cases.

Some key takeaways for this week:
1️⃣ Mastering prompt crafting – Learning how to frame prompts for optimal Copilot responses.
2️⃣ Exploring developer AI use cases – Seeing how Copilot fits into various workflows.

With all these resources (videos, blogs, and Microsoft Learn modules), there’s plenty to dive into. What part of prompt engineering are you most excited to explore? 🤔

[paulsuv9]

What specific part of prompt engineering did you find most exciting to explore this week, @RAVINDRA8008?

[RAVINDRA8008]

great question, @paulsuv9 This week, I really enjoyed exploring how small tweaks in prompt phrasing can drastically improve Copilot’s responses. Being more explicit with requirements, like specifying performance constraints or expected output formats, made a big difference! 🚀 What about you? Any cool insights from your end

[paulsuv9]

Thanks, @RAVINDRA8008! 🚀 I’ve also found that being specific with prompts makes a huge difference. For example, specifying ‘optimize for memory usage’ or ‘generate tests for edge cases’ has helped me get more accurate and useful suggestions from Copilot. One cool insight I discovered is using Copilot to generate privacy-focused scripts that anonymize user data before processing. It’s been a great addition to our data handling practices! What’s been your favorite prompt tweak so far?

[pintuyadav5468]

answers:

1.Which practices could introduce legal or security risks?
✅ A) Using Copilot to generate code for encryption algorithms without verification.
✅ C) Accepting Copilot-generated code that lacks licensing information.

2.Best way to optimize Copilot’s inline chat for debugging?
✅ A) Rewriting prompts to be more detailed, explicitly mentioning expected outputs.

3.Why is the sorting function suboptimal for large datasets?
✅ C) The function does not use an in-place sorting method like data.sort().

4.Why does Copilot omit memoization in Fibonacci function?
✅ C) Copilot lacks context about performance optimizations unless explicitly prompted.

5.What should developers be cautious about with SQL query generation?
✅ B) Copilot might suggest queries vulnerable to SQL injection.

6.Why do Copilot's suggestions contain unfamiliar snippets in a private repo?
✅ A) Copilot is retrieving suggestions from similar open-source projects.
✅ B) Copilot is generating code based on patterns detected in the project’s existing files.

7.What to do when a Copilot-generated SQL query lacks indexing considerations?
✅ A) Add a comment specifying performance constraints and indexing requirements.

8. Best prompt for optimized SQL query generation?
   ✅ B) # Write an optimized SQL query that retrieves customer data using an index on customer_id.

9. Best approach to prevent Copilot from suggesting public implementations?
   ✅ A) Use private repositories with Copilot to limit exposure to public code patterns.
   ✅ B) Explicitly describe unique constraints and design principles in inline comments.

10.Factors that contribute most to increased developer productivity with Copilot?
✅ A) Reduction in the time spent searching for solutions on external websites.
✅ D) Faster onboarding of new developers due to AI-assisted code understanding.

11.Factors that influence Copilot’s ability to generate high-quality completions?
✅ A) The recency of the training data used to build the model.
✅ B) The user's coding patterns and past accepted suggestions.

12.Strategies to improve Copilot's relevance when it suggests outdated API methods?
✅ A) Add a comment explicitly mentioning the latest API version before the function definition.
✅ B) Use natural language prompts that describe the intent of the code rather than function names.

13.Best way to guide Copilot to generate better ML model training functions?
✅ A) Use inline comments to specify preferred hyperparameters and model architectures.

[Parthapnath]

Week 3 questions were a bit tricky but it was also fun learning about prompt engeneering and productivity.

[paulsuv9]

This week, I learned that framing prompts with specific constraints can drastically improve Copilot’s output. One tip is to always specify the expected output format and any performance constraints.

[paulsuv9]

I used the prompt engineering techniques from this week to optimize a sorting algorithm in my project, which improved its performance by 30%.

[RAVINDRA8008]

That’s awesome! 🚀 A 30% performance boost is impressive! Which sorting algorithm did you optimize, and what specific prompt engineering techniques helped the most? I’d love to hear more about your approach!

[paulsuv9]

Thanks, @RAVINDRA8008! 🚀 I optimized the QuickSort algorithm. The key prompt engineering techniques that helped the most were specifying the constraints and expected performance improvements. For example, I used prompts like ‘Optimize QuickSort for large datasets with a focus on reducing time complexity.’ This guided Copilot to generate more efficient code. What about you? Have you tried optimizing any other algorithms with Copilot?

[paulsuv9]

I found that using Copilot for generating SQL queries saved me a lot of time. Has anyone else had a similar experience?

[RAVINDRA8008]

Absolutely! 🚀 Copilot has been a game-changer for writing complex SQL queries quickly. It even helps with optimizing queries and suggesting indexes. Have you tried using it for database schema design or migrations?

[paulsuv9]

That’s awesome to hear, @RAVINDRA8008! I haven’t tried it for database schema design yet, but it sounds like a great idea. I’ll definitely give it a shot. Have you found any specific prompts that work well for schema design or migrations?

[paulsuv9]

Here are my answers to this week's questions:

1. Legal and Security Risks

Question: When using GitHub Copilot in a corporate environment, which of the following practices could introduce legal or security risks? (Select two)

• Answer: A) Using Copilot to generate code for encryption algorithms without verification. C) Accepting Copilot-generated code that lacks licensing information.
• 💡 Tip: Always review and verify Copilot-generated code, especially for security-critical components like encryption, and ensure that any code used complies with licensing requirements.

2. Optimizing Copilot’s Inline Chat for Debugging

Question: A developer is working with Copilot in Visual Studio and wants to optimize Copilot’s inline chat for debugging. What is the best way to achieve this?

• Answer: A) Rewriting prompts to be more detailed, explicitly mentioning expected outputs.
• 💡 Tip: Provide clear, detailed instructions, including the expected behavior and any error messages, to help Copilot understand the context and provide more relevant debugging suggestions.

3. Sorting Function for Large Datasets

Question: A developer is using GitHub Copilot to generate a function for sorting a large dataset (100,000+ entries). Why might this function be suboptimal for large datasets?

• Answer: C) The function does not use an in-place sorting method like data.sort().
• 💡 Tip: For large datasets, use in-place sorting methods to reduce memory usage and improve performance.

4. Fibonacci Function without Memoization

Question: A developer asks Copilot to generate a function that computes Fibonacci numbers. The suggested function uses recursion but lacks memoization. What is the most likely reason for this omission?

• Answer: C) Copilot lacks context about performance optimizations unless explicitly prompted.
• 💡 Tip: Explicitly prompt Copilot for performance optimizations, such as memoization, to ensure efficient code generation.

5. SQL Query Generation Cautions

Question: When using GitHub Copilot for SQL query generation, what should developers be cautious about?

• Answer: B) Copilot might suggest queries vulnerable to SQL injection.
• 💡 Tip: Always review and sanitize Copilot-generated SQL queries to prevent SQL injection vulnerabilities.

6. Unfamiliar Code Snippets in Private Repo

Question: A team is using Copilot for collaborative development. Developer A enables Copilot in a private repository. Developer B, working in the same repository, notices Copilot's suggestions contain code snippets that look unfamiliar. What might be happening?

• Answer: B) Copilot is generating code based on patterns detected in the project’s existing files.
• 💡 Tip: Ensure that all team members are aware of the patterns and coding standards used in the project to maintain consistency.

7. SQL Query Lacking Indexing Considerations

Question: You request Copilot to generate a SQL query but notice that the suggested query lacks proper indexing considerations. What should you do?

• Answer: A) Add a comment specifying performance constraints and indexing requirements.
• 💡 Tip: Provide explicit context about performance needs and indexing requirements to improve the relevance of Copilot's suggestions.

8. Best Prompt for Optimized SQL Query Generation

Question: A developer needs Copilot to generate optimized SQL queries. What prompt will yield the best results?

• Answer: B) # Write an optimized SQL query that retrieves customer data using an index on customer_id.
• 💡 Tip: Be specific about optimization requirements and indexing to guide Copilot in generating efficient queries.

9. Protecting Proprietary Algorithms

Question: A team is developing a proprietary algorithm and wants to ensure Copilot does not suggest code similar to public implementations. What is the best approach? (Select two)

• Answer: A) Use private repositories with Copilot to limit exposure to public code patterns. B) Explicitly describe unique constraints and design principles in inline comments.
• 💡 Tip: Use private repositories and provide detailed comments about unique aspects of the algorithm to prevent Copilot from suggesting generic solutions.

10. Factors Contributing to Increased Developer Productivity

Question: According to research on GitHub Copilot's impact, which of the following factors contribute most significantly to increased developer productivity when using Copilot? (Select two)

• Answer: A) Reduction in the time spent searching for solutions on external websites. D) Faster onboarding of new developers due to AI-assisted code understanding.
• 💡 Tip: Utilize Copilot to minimize context switching and accelerate learning new programming languages and frameworks.

11. Factors Influencing Completion Quality

Question: Which of the following factors most significantly influence GitHub Copilot’s ability to generate high-quality completions? (Select two)

• Answer: A) The recency of the training data used to build the model. B) The user's coding patterns and past accepted suggestions.
• 💡 Tip: Keep your coding patterns consistent and provide feedback on Copilot's suggestions to improve its relevance.

12. Improving Relevance of Suggestions

Question: You are using GitHub Copilot in Visual Studio Code and notice that it frequently suggests outdated API methods that have been deprecated. What are the most effective strategies to improve the relevance of suggestions? (Select two)

• Answer: A) Add a comment explicitly mentioning the latest API version before the function definition. B) Use natural language prompts that describe the intent of the code rather than function names.
• 💡 Tip: Provide clear context about the desired API version and describe the intent of the code to ensure up-to-date suggestions.

13. Guiding Copilot for Better ML Model Training Functions

Question: A developer is building a machine learning model in Python. They ask GitHub Copilot to generate a function for model training but notice that Copilot repeatedly suggests suboptimal hyperparameter choices. What is the best way to guide Copilot to generate better completions?

• Answer: A) Use inline comments to specify preferred hyperparameters and model architectures.
• 💡 Tip: Provide explicit guidance on desired hyperparameters and model structures to influence Copilot's suggestions.

[Ronaldo-001]

Great answers @paulsuv9

[kareem1207]

Sorry for begin late and last to answer , Thanks for this wonderful course, @Akash1134. These are my answers, and I hope they are right:

1. When using GitHub Copilot in a corporate environment, which of the following practices could introduce legal or security risks? (Select two)
   A) Using Copilot to generate code for encryption algorithms without verification.✅
   B) Enabling Copilot to suggest code completions within a private enterprise repository.
   C) Accepting Copilot-generated code that lacks licensing information.✅
   D) Using Copilot in an IDE that does not support secure API calls.

2. A developer is working with Copilot in Visual Studio and wants to optimize Copilot’s inline chat for debugging. What is the best way to achieve this?
   A) Rewriting prompts to be more detailed, explicitly mentioning expected outputs.✅
   B) Running Copilot Chat multiple times to get varied debugging suggestions.
   C) Adjusting Copilot’s temperature parameter to control randomness in responses.
   D) Restricting Copilot Chat to only use file-specific context rather than project-wide scope.

3. A developer is using GitHub Copilot to generate a function for sorting a large dataset (100,000+ entries). Copilot suggests the following function:
   python
   Copy
   Edit
   def sort_data(data):
   return sorted(data)
   Why might this function be suboptimal for large datasets?
   A) The sorted() function is not efficient for large datasets.✅
   B) The function lacks an explicit sorting algorithm, making it unpredictable.
   C) The function does not use an in-place sorting method like data.sort().
   D) Copilot might suggest a less efficient sorting algorithm if not prompted explicitly.

4. A developer asks Copilot to generate a function that computes Fibonacci numbers. The suggested function uses recursion but lacks memoization. What is the most likely reason for this omission?
   A) Copilot prioritizes standard implementations seen in open-source projects.
   B) Copilot avoids generating computationally expensive algorithms.
   C) Copilot lacks context about performance optimizations unless explicitly prompted.✅
   D) Copilot assumes the user will manually optimize the generated code.

5. When using GitHub Copilot for SQL query generation, what should developers be cautious about?
   A) Copilot always generates the most optimized query.
   B) Copilot might suggest queries vulnerable to SQL injection.✅
   C) Copilot does not support SQL query generation.
   D) Copilot automatically optimizes database indexes.

6. A team is using Copilot for collaborative development. Developer A enables Copilot in a private repository. Developer B, working in the same repository, notices Copilot's suggestions contain code snippets that look unfamiliar. What might be happening?
   A) Copilot is retrieving suggestions from similar open-source projects.
   B) Copilot is generating code based on patterns detected in the project’s existing files.✅
   C) Copilot is using external AI models to fetch relevant public code snippets.
   D) Copilot is applying prompt engineering techniques to infer missing logic.

7. You request Copilot to generate a SQL query but notice that the suggested query lacks proper indexing considerations. What should you do?
   A) Add a comment specifying performance constraints and indexing requirements.✅
   B) Re-prompt Copilot with a more detailed query request.
   C) Accept the query and manually optimize it.
   D) Adjust Copilot’s model settings to prioritize efficiency.

8. A developer needs Copilot to generate optimized SQL queries. What prompt will yield the best results?
   A) # Generate an SQL query to retrieve customer data.
   B) # Write an optimized SQL query that retrieves customer data using an index on customer_id.✅
   C) # Write an SQL query for fetching customer data using JOINs.
   D) # Generate a basic SQL query to fetch all rows from the customers table.

9. A team is developing a proprietary algorithm and wants to ensure Copilot does not suggest code similar to public implementations. What is the best approach? (Select two)
   A) Use private repositories with Copilot to limit exposure to public code patterns.✅
   B) Explicitly describe unique constraints and design principles in inline comments.✅
   C) Turn off Copilot suggestions for functions that contain proprietary logic.
   D) Modify Copilot's training dataset to exclude certain open-source projects.

10. According to research on GitHub Copilot's impact, which of the following factors contribute most significantly to increased developer productivity when using Copilot? (Select two correct answers)
    A) Reduction in the time spent searching for solutions on external websites.✅
    B) Increased number of lines of code written per hour.✅
    C) A higher frequency of completed pull requests per developer.
    D) Faster onboarding of new developers due to AI-assisted code understanding.

11. Which of the following factors most significantly influence GitHub Copilot’s ability to generate high-quality completions? (Select two)
    A) The recency of the training data used to build the model.✅
    B) The user's coding patterns and past accepted suggestions.
    C) The number of times the user has prompted Copilot in a single session.
    D) Whether the user is working in an IDE or a browser-based editor.✅

12. You are using GitHub Copilot in Visual Studio Code and notice that it frequently suggests outdated API methods that have been deprecated. What are the most effective strategies to improve the relevance of suggestions? (Select two)
    A) Add a comment explicitly mentioning the latest API version before the function definition.✅
    B) Use natural language prompts that describe the intent of the code rather than function names.✅
    C) Adjust the settings to restrict Copilot to suggestions from private repositories only.
    D) Revert to an older version of GitHub Copilot that was trained on previous API versions.

13. A developer is building a machine learning model in Python. They ask GitHub Copilot to generate a function for model training but notice that Copilot repeatedly suggests suboptimal hyperparameter choices. What is the best way to guide Copilot to generate better completions?
    A) Use inline comments to specify preferred hyperparameters and model architectures.✅
    B) Accept a Copilot suggestion and manually tweak the parameters later.
    C) Change the function name to include terms like “optimized” or “efficient.”
    D) Train Copilot on previous successful models to improve its suggestions

[Akash1134]

Thank you all for joining another learning packed week and sharing your Prompt responses. Here are the correct answers:

1. When using GitHub Copilot in a corporate environment, which of the following practices could introduce legal or security risks? (Select two)

• A) Using Copilot to generate code for encryption algorithms without verification.
• B) Enabling Copilot to suggest code completions within a private enterprise repository.
• C) Accepting Copilot-generated code that lacks licensing information.
• D) Using Copilot in an IDE that does not support secure API calls.
• Answer: A) Using Copilot to generate code for encryption algorithms without verification.
  C) Accepting Copilot-generated code that lacks licensing information.

Reasoning:
Copilot-generated encryption code may contain vulnerabilities if not carefully reviewed. Additionally, generated code may lack proper licensing details, which can create legal risks in corporate environments.

2. A developer is working with Copilot in Visual Studio and wants to optimize Copilot’s inline chat for debugging. What is the best way to achieve this?

• A) Rewriting prompts to be more detailed, explicitly mentioning expected outputs.
• B) Running Copilot Chat multiple times to get varied debugging suggestions.
• C) Adjusting Copilot’s temperature parameter to control randomness in responses.
• D) Restricting Copilot Chat to only use file-specific context rather than project-wide scope.
• Answer: A) Rewriting prompts to be more detailed, explicitly mentioning expected outputs.

Reasoning:
More detailed prompts provide clearer guidance, improving Copilot’s debugging responses. The model’s behavior is not directly adjustable via temperature tuning.

3. A developer is using GitHub Copilot to generate a function for sorting a large dataset (100,000+ entries). Copilot suggests the following function:

def sort_data(data):
    return sorted(data)

Why might this function be suboptimal for large datasets?

• A) The sorted() function is not efficient for large datasets.
• B) The function lacks an explicit sorting algorithm, making it unpredictable.
• C) The function does not use an in-place sorting method like data.sort().
• D) Copilot might suggest a less efficient sorting algorithm if not prompted explicitly.
• Answer: C) The function does not use an in-place sorting method like data.sort().
  D) Copilot might suggest a less efficient sorting algorithm if not prompted explicitly.

Reasoning:
The sorted() function creates a new list, consuming extra memory, whereas data.sort() sorts in place, making it more efficient for large datasets. Copilot's default suggestions might not prioritize efficiency unless explicitly guided.

4. A developer asks Copilot to generate a function that computes Fibonacci numbers. The suggested function uses recursion but lacks memoization. What is the most likely reason for this omission?

• A) Copilot prioritizes standard implementations seen in open-source projects.
• B) Copilot avoids generating computationally expensive algorithms.
• C) Copilot lacks context about performance optimizations unless explicitly prompted.
• D) Copilot assumes the user will manually optimize the generated code.
• Answer: A) Copilot prioritizes standard implementations seen in open-source projects.
  C) Copilot lacks context about performance optimizations unless explicitly prompted.

Reasoning:
Copilot generates code based on common patterns, often reflecting standard implementations unless guided by explicit performance-related prompts. Memoization is an optimization that must be explicitly requested.

5. When using GitHub Copilot for SQL query generation, what should developers be cautious about?

• A) Copilot always generates the most optimized query.
• B) Copilot might suggest queries vulnerable to SQL injection.
• C) Copilot does not support SQL query generation.
• D) Copilot automatically optimizes database indexes.
• Answer: B) Copilot might suggest queries vulnerable to SQL injection.

Reasoning:
Copilot generates code based on patterns but does not inherently enforce security best practices. Developers should always validate and sanitize user inputs to prevent SQL injection.

6. A team is using Copilot for collaborative development. Developer A enables Copilot in a private repository. Developer B, working in the same repository, notices Copilot's suggestions contain code snippets that look unfamiliar. What might be happening?

• A) Copilot is retrieving suggestions from similar open-source projects.
• B) Copilot is generating code based on patterns detected in the project’s existing files.
• C) Copilot is using external AI models to fetch relevant public code snippets.
• D) Copilot is applying prompt engineering techniques to infer missing logic.
• Answer: B) Copilot is generating code based on patterns detected in the project’s existing files.

Reasoning:
Copilot suggests code by analyzing existing project files but does not fetch code from external repositories. If unfamiliar snippets appear, they might be inferred from existing patterns in the repository.

7. You request Copilot to generate a SQL query but notice that the suggested query lacks proper indexing considerations. What should you do?

• A) Add a comment specifying performance constraints and indexing requirements.
• B) Re-prompt Copilot with a more detailed query request.
• C) Accept the query and manually optimize it.
• D) Adjust Copilot’s model settings to prioritize efficiency.
• Answer: A) Add a comment specifying performance constraints and indexing requirements.
  B) Re-prompt Copilot with a more detailed query request.

Reasoning:
Copilot’s suggestions improve with clearer prompts. By specifying indexing constraints, developers can guide Copilot toward generating optimized queries.

8. A developer needs Copilot to generate optimized SQL queries. What prompt will yield the best results?

• A) Generate an SQL query to retrieve customer data.
• B) Write an optimized SQL query that retrieves customer data using an index on customer_id.
• C) Write an SQL query for fetching customer data using JOINs.
• D) Generate a basic SQL query to fetch all rows from the customers table.
• Answer: B) Write an optimized SQL query that retrieves customer data using an index on customer_id.

Reasoning:
Explicitly specifying an index guides Copilot to generate a more efficient query rather than a generic one.

9. A team is developing a proprietary algorithm and wants to ensure Copilot does not suggest code similar to public implementations. What is the best approach? (Select two)

• A) Use private repositories with Copilot to limit exposure to public code patterns.
• B) Explicitly describe unique constraints and design principles in inline comments.
• C) Turn off Copilot suggestions for functions that contain proprietary logic.
• D) Modify Copilot's training dataset to exclude certain open-source projects.
• Answer: A) Use private repositories with Copilot to limit exposure to public code patterns.
  B) Explicitly describe unique constraints and design principles in inline comments.

Reasoning:
Copilot’s suggestions are influenced by existing patterns. Using private repositories and providing explicit context helps ensure originality.

10. According to research on GitHub Copilot's impact, which of the following factors contribute most significantly to increased developer productivity when using Copilot? (Select two correct answers)

• A) Reduction in the time spent searching for solutions on external websites.
• B) Increased number of lines of code written per hour.
• C) A higher frequency of completed pull requests per developer.
• D) Faster onboarding of new developers due to AI-assisted code understanding.
• Answer: A) Reduction in the time spent searching for solutions on external websites.
  D) Faster onboarding of new developers due to AI-assisted code understanding.

Reasoning:
Copilot improves efficiency by reducing context-switching and enabling quicker learning for new developers.

11. A developer is using Copilot to generate test cases for a function. The generated tests do not cover edge cases. What is the most likely reason?

• A) Copilot is designed to generate only basic test cases unless explicitly guided.
• B) Copilot does not support unit test generation.
• C) Copilot intentionally avoids complex test scenarios to reduce execution time.
• D) Copilot assumes the user will manually add edge cases.
• Answer: A) Copilot is designed to generate only basic test cases unless explicitly guided.

Reasoning:
Copilot suggests test cases based on common patterns but does not automatically generate exhaustive edge-case coverage unless explicitly prompted.

12. A developer notices that Copilot is suggesting variable names that seem unrelated to their project. What might be the cause?

• A) Copilot's suggestions are influenced by commonly used open-source patterns.
• B) Copilot generates variable names randomly without context.
• C) Copilot does not analyze the surrounding code before generating suggestions.
• D) Copilot is designed to avoid using context-specific variable names.
• Answer: A) Copilot's suggestions are influenced by commonly used open-source patterns.

Reasoning:
Copilot generates suggestions based on widely used naming conventions from open-source projects unless it has sufficient context from the surrounding code.

13. A developer wants Copilot to suggest code that follows their team’s specific coding style. What is the best approach? (Select two)

• A) Add detailed comments specifying coding style preferences.
• B) Train Copilot with custom datasets containing the team’s codebase.
• C) Provide Copilot with well-structured examples in the existing project.
• D) Adjust Copilot’s internal configuration settings for style enforcement.
• Answer: A) Add detailed comments specifying coding style preferences.
  C) Provide Copilot with well-structured examples in the existing project.

Reasoning:
Copilot improves its suggestions when given clear examples and guidance in the form of comments or surrounding code. Custom training and internal configuration are not available options for end users.

Now, get ready for Week 4, the final lap! Next week, we’ll dive into advanced scenarios of Testing and Security & Privacy of GitHub Copilot. It’s the perfect opportunity to tie everything together and use Copilot Free to its fullest. You’ve come so far—one last push to the finish line!. 🏁

See you all on Monday with another exciting week ahead. 🚀

[johnniekpng]

Question 11 and 12 are changed

[RAVINDRA8008]

Here are my answers to the GitHub Copilot knowledge checkpoint:

1. Legal & Security Risks
   ✅ A) Using Copilot to generate code for encryption algorithms without verification.
   ✅ C) Accepting Copilot-generated code that lacks licensing information.

Reasoning: Copilot may generate code that does not comply with security best practices or licensing requirements, potentially exposing organizations to legal or security issues.

2. Optimizing Copilot’s Inline Chat for Debugging
   ✅ A) Rewriting prompts to be more detailed, explicitly mentioning expected outputs.

Reasoning: Clear, detailed prompts help Copilot provide relevant debugging insights.

3. Sorting Large Datasets
   ✅ C) The function does not use an in-place sorting method like data.sort().

Reasoning: sorted(data) creates a new list rather than sorting in place, which can be inefficient in terms of memory for large datasets.

4. Omission of Memoization in Fibonacci Function
   ✅ C) Copilot lacks context about performance optimizations unless explicitly prompted.

Reasoning: Copilot generates standard implementations unless instructed to optimize for performance.

5. SQL Query Generation Risks
   ✅ B) Copilot might suggest queries vulnerable to SQL injection.

Reasoning: Copilot-generated SQL queries may not always include proper security measures like parameterized queries.

6. Unfamiliar Code Snippets in Private Repository
   ✅ A) Copilot is retrieving suggestions from similar open-source projects.
   ✅ B) Copilot is generating code based on patterns detected in the project’s existing files.

Reasoning: Copilot suggests completions based on both public data and the project's context, sometimes leading to unfamiliar-looking code.

7. Improving SQL Query Suggestions
   ✅ A) Add a comment specifying performance constraints and indexing requirements.
   ✅ B) Re-prompt Copilot with a more detailed query request.

Reasoning: Providing context helps Copilot generate optimized queries.

8. Best Prompt for Optimized SQL Query
   ✅ B) # Write an optimized SQL query that retrieves customer data using an index on customer_id.

Reasoning: This explicitly instructs Copilot to consider performance optimizations.

9. Avoiding Public Code Similarities
   ✅ A) Use private repositories with Copilot to limit exposure to public code patterns.
   ✅ B) Explicitly describe unique constraints and design principles in inline comments.

Reasoning: Keeping Copilot’s scope limited and providing clear constraints reduces similarity to public code.

10. Productivity Gains with Copilot
    ✅ A) Reduction in the time spent searching for solutions on external websites.
    ✅ D) Faster onboarding of new developers due to AI-assisted code understanding.

Reasoning: Copilot reduces search time and helps new developers quickly grasp codebases.

11. Factors Influencing High-Quality Completions
    ✅ A) The recency of the training data used to build the model.
    ✅ B) The user's coding patterns and past accepted suggestions.

Reasoning: Copilot improves based on recent training data and adapts to individual coding habits.

12. Preventing Deprecated API Suggestions
    ✅ A) Add a comment explicitly mentioning the latest API version before the function definition.
    ✅ B) Use natural language prompts that describe the intent of the code rather than function names.

Reasoning: Giving explicit context helps Copilot generate up-to-date and intent-based suggestions.

13. Improving ML Model Training Suggestions
    ✅ A) Use inline comments to specify preferred hyperparameters and model architectures.

Reasoning: Providing specific guidance helps Copilot generate better model training functions.

[paulsuv9]

Great answers, @RAVINDRA8008! 📝 Your reasoning is spot on. It’s crucial to review and verify Copilot-generated code, especially for security-critical components. Have you encountered any specific challenges or best practices when using Copilot in a corporate environment?

[mvark]

The Knowledge Check questions in the Microsoft Learn modules and those posted here have been helpful in deepening my understanding of the topics. I've been gathering the reasoning behind the answers for exam preparation and future reference and it's growing each week.

Some of the options to the questions were thought provoking. For instance, the option "Copilot is using external AI models to fetch relevant public code snippets." in Q6. That made me wonder what it would be like with Retrieval-Augmented Generation (RAG) support for real-time external code retrieval.

My answers to Week 3 questions -

1 A,C) Using Copilot to generate code for encryption algorithms without verification and accepting Copilot-generated code that lacks licensing information. could introduce legal or security risks when using GitHub Copilot in a corporate environment.

2 A) To optimize GitHub Copilot’s inline chat for debugging, rewrite prompts to be more detailed, explicitly mentioning expected outputs.

3 D) Copilot might suggest a less efficient sorting algorithm if not prompted explicitly.

4 C) The most likely reason a GitHub Copilot suggested function uses recursion but lacks memoization while computing Fibonacci numbers is that lacks context about performance optimizations unless explicitly prompted.

Memoization is an optimization technique that might not be included in the most straightforward or common implementations found in training data, especially if the function is simple and lacks context about performance needs.

5 B) When using GitHub Copilot for SQL query generation, Copilot might suggest queries vulnerable to SQL injection.

6 B) GitHub Copilot is designed to generate code suggestions based on the context of the codebase it is working within. When enabled in a private repository, Copilot uses machine learning models trained on a vast amount of code to generate suggestions that align with the coding patterns and styles observed in the project’s existing files. This means that the suggestions it provides are tailored to fit the specific context of the project, rather than retrieving code from similar open-source projects or external sources.

Copilot doesn't directly fetch external code in real-time

7 B) Copilot generates responses based on the input it receives. If the initial prompt lacks specific requirements about performance and indexing, the generated query might not include these considerations. Re-prompting with more detailed requirements allows Copilot to understand the complete context and generate a more optimized query. You can specify performance requirements, expected data volume, and indexing needs in the new prompt.

8 B) To yield the best results for generating optimized SQL queries using Copilot, the prompt should be specific, clear, and detailed about the optimization requirements.

9 A, B) The best approach to prevent Copilot from suggesting code similar to public implementations of a proprietary algorithm is to use private repositories with Copilot to limit exposure to public code patterns and explicitly describing unique constraints and design principles in inline comments.

Turning off Copilot suggestions for functions with proprietary logic is overly restrictive

Users cannot modify Copilot's training dataset - this is controlled by GitHub/Microsoft

10 A,D)The factors that contribute most significantly to increased developer productivity when using GitHub Copilot are:

Reduction in the time spent searching for solutions on external websites.
Faster onboarding of new developers due to AI-assisted code understanding.
While increased number of lines of code written per hour and a higher frequency of completed pull requests per developer are beneficial outcomes of using Copilot, they are not the primary contributors to increased developer productivity when compared to the above 2 factors.

11 A,B) The factors that most significantly influence GitHub Copilot’s ability to generate high-quality completions are the recency of the training data used to build the model and the user's coding patterns and past accepted suggestions.

12 A,B) To improve the relevance of suggestions from GitHub Copilot in Visual Studio Code, the most effective strategies would be:

Add a comment explicitly mentioning the latest API version before the function definition.
Use natural language prompts that describe the intent of the code rather than function names.

13 A) The best way to guide GitHub Copilot to generate better completions for a machine learning model in Python, especially when it comes to suggesting suboptimal hyperparameter choices, is to provide explicit guidance within the code itself. This can be effectively done by using inline comments to specify preferred hyperparameters and model architectures. By doing so, the developer directly communicates their preferences and requirements to Copilot, allowing it to generate more tailored and appropriate suggestions.

[RAVINDRA8008]

🚀 GitHub Copilot Challenge! 🔥

Think you're a Copilot pro? Let’s test your skills! 💡

Question 1

What’s the best way to ensure high-quality code suggestions from Copilot?

• A) Using generic prompts
• B) Providing detailed and specific prompts
• C) Relying entirely on Copilot without modifications
• D) Using outdated syntax and methods

Question 2

Which of the following is NOT a best practice when prompting Copilot?

• A) Clearly stating expected outputs
• B) Including performance constraints in comments
• C) Writing vague, one-word prompts
• D) Using Copilot to generate test cases

Question 3

Why does Copilot sometimes generate suboptimal SQL queries?

• A) It lacks awareness of indexing and optimization unless explicitly prompted
• B) It always generates optimized queries by default
• C) It only generates queries based on the latest SQL standards
• D) It ignores user-provided constraints

Question 4

Which of the following poses a security risk when using Copilot?

• A) Using Copilot to generate simple utility functions
• B) Allowing Copilot to generate encryption algorithms without verification
• C) Reviewing Copilot-generated code before using it
• D) Using Copilot in private repositories only

Question 5

How can developers reduce the risk of Copilot-generated code violating licenses?

• A) Accepting all code without verification
• B) Checking if the generated code includes licensing information
• C) Avoiding the use of inline comments for context
• D) Relying on Copilot to handle legal issues

Question 6

What is a potential risk of using Copilot for SQL query generation?

• A) Copilot always generates secure queries
• B) Copilot might generate queries vulnerable to SQL injection
• C) Copilot ignores user input
• D) Copilot only suggests parameterized queries

Question 7

Why might Copilot fail to use memoization in a recursive function?

• A) Copilot does not understand recursion
• B) Copilot lacks context about performance optimization unless explicitly prompted
• C) Copilot always optimizes for performance automatically
• D) Copilot does not support dynamic programming techniques

Question 8

What is the key reason for using inline comments when asking Copilot for code?

• A) To help Copilot generate more accurate and optimized suggestions
• B) To make the code look more professional
• C) To confuse Copilot into generating unexpected results
• D) To prevent Copilot from suggesting any code

Question 9

Which of the following is a good strategy for improving Copilot's debugging suggestions?

• A) Using detailed prompts that mention expected outputs
• B) Ignoring Copilot’s suggestions and debugging manually
• C) Asking Copilot in a single-word prompt
• D) Relying on Copilot-generated code without testing

Question 10

What is a unique way Copilot can assist developers besides writing code?

• A) Writing documentation and comments
• B) Making business decisions
• C) Running unit tests automatically
• D) Fixing all security vulnerabilities

---

💬 Drop your answers in the comments! Let’s see who gets a 10/10! 🎯🔥
🚀 React with 🚀 if you want more challenges! 😏

[RAVINDRA8008]

✅ GitHub Copilot Challenge - Answer Key & Explanations! 🎯

Question 1: What’s the best way to ensure high-quality code suggestions from Copilot?

✅ Answer: B) Providing detailed and specific prompts
🔹 Explanation: Copilot works best when given clear, detailed, and contextual instructions. Vague prompts lead to generic or incorrect suggestions.

---

Question 2: Which of the following is NOT a best practice when prompting Copilot?

✅ Answer: C) Writing vague, one-word prompts
🔹 Explanation: One-word prompts lack context, leading to unreliable or random suggestions. Instead, use detailed comments explaining your requirements.

---

Question 3: Why does Copilot sometimes generate suboptimal SQL queries?

✅ Answer: A) It lacks awareness of indexing and optimization unless explicitly prompted
🔹 Explanation: Copilot does not automatically optimize SQL queries for performance unless instructed. Always specify indexing, constraints, and query structure.

---

Question 4: Which of the following poses a security risk when using Copilot?

✅ Answer: B) Allowing Copilot to generate encryption algorithms without verification
🔹 Explanation: Copilot might suggest insecure or outdated encryption methods. Always review and use trusted cryptography libraries instead.

---

Question 5: How can developers reduce the risk of Copilot-generated code violating licenses?

✅ Answer: B) Checking if the generated code includes licensing information
🔹 Explanation: Some Copilot-generated code may come from open-source repositories with specific licenses. Always verify the source and comply with legal terms.

---

Question 6: What is a potential risk of using Copilot for SQL query generation?

✅ Answer: B) Copilot might generate queries vulnerable to SQL injection
🔹 Explanation: If Copilot suggests SQL queries without parameterization, they might be vulnerable to SQL injection attacks. Always validate and sanitize inputs.

---

Question 7: Why might Copilot fail to use memoization in a recursive function?

✅ Answer: B) Copilot lacks context about performance optimization unless explicitly prompted
🔹 Explanation: Copilot does not always optimize for performance unless you guide it. Including comments like "Use memoization to improve efficiency" helps.

---

Question 8: What is the key reason for using inline comments when asking Copilot for code?

✅ Answer: A) To help Copilot generate more accurate and optimized suggestions
🔹 Explanation: Inline comments provide crucial context, helping Copilot generate better, more relevant code instead of generic solutions.

---

Question 9: Which of the following is a good strategy for improving Copilot's debugging suggestions?

✅ Answer: A) Using detailed prompts that mention expected outputs
🔹 Explanation: If you specify expected results or error conditions, Copilot can refine its debugging suggestions more effectively.

---

Question 10: What is a unique way Copilot can assist developers besides writing code?

✅ Answer: A) Writing documentation and comments
🔹 Explanation: Copilot is not just for coding—it can generate docstrings, README files, and inline comments to improve code maintainability.

---

🎯 How many did you get right? Drop your score in the comments!
🔥 Want another challenge? React with 🚀!

💡 If there's any mistake, please forgive me! Feel free to correct or discuss in the comments. 😊

[paulsuv9]

Great challenge, @RAVINDRA8008! 🚀 Thanks for sharing the answers alongside, my bad, I missed it, it's definitely fun to see what you have cooked up 😊. Have you noticed any other tips that help improve the quality of Copilot’s suggestions?

[RAVINDRA8008]

🚀 GitHub Copilot Week 3 - Mastering Prompt Engineering & Productivity 🎯

👋 Hey everyone!

We're now at the halfway mark in our GitHub Copilot learning journey, and it's amazing to see the dedication and creativity in your submissions so far!

This week, we focus on prompt engineering and productivity—two critical skills that will supercharge your experience with Copilot. Learning to craft better prompts will help you unlock higher quality code suggestions and enhance your workflow.

📌 What’s in Store for This Week?

🔥 Key Topics:
✅ Fundamentals of Prompt Crafting & Engineering
✅ Developer use cases for AI with Copilot
✅ Improving developer productivity
✅ Copilot’s impact on the Software Development Life Cycle (SDLC)
✅ Limitations of Copilot and how to work around them
✅ How to use the Productivity API to measure Copilot’s coding impact

---

🎯 💡 Interactive Activities - Let’s Learn by Doing!

🔥 Activity 1: The Prompt Engineering Challenge 📝

💡 Task: Improve a basic prompt to get better Copilot-generated code.

🔹 Basic Prompt:

# Write a function to reverse a string
def reverse_string(s):
    return s[::-1]

🔹 Improved Prompt for Copilot:

# Write a Python function to reverse a string without using slicing
# Ensure the function works with spaces and special characters
# Add a test case at the end

🛠 Your Task:
✅ Test both prompts in Copilot.
✅ Share the differences in output.
✅ Experiment with different languages (JS, Java, SQL) and report your findings!

---

🐞 Activity 2: Debugging with Copilot - Fix the Bug!

🔹 Buggy Copilot Suggestion:

def divide_numbers(a, b):
    return a / b

⚠️ Issue: This breaks if b = 0.

🔹 Better Prompt:

# Write a function that safely divides two numbers
# Handle division by zero by returning "undefined"

🔹 Expected Copilot Fix:

def divide_numbers(a, b):
    if b == 0:
        return "undefined"
    return a / b

🛠 Your Task:
✅ Run the buggy code and refine the prompt for better output.
✅ Test in JavaScript, Java, or C++ to compare results!

---

⏳ Activity 3: AI Productivity Sprint - Save Time with Copilot!

🔹 Goal: Use Copilot for 30 minutes and track how much time you save.

💡 Example Tasks:
✔️ Generate a unit test for a function.
✔️ Write a SQL query to find the highest-paid employee.
✔️ Create a JavaScript function to filter unique values from an array.

🛠 After the Sprint:
✅ Share your results! Did Copilot speed up your workflow?
✅ Discuss challenges & solutions.

---

🏆 Final Discussion: What Did We Learn?

💡 Which prompt structures gave the best results?
💡 What techniques improved Copilot’s suggestions?
💡 Where did Copilot struggle, and how did you fix it?

🎖️ Top participants will earn a GitHub Certification exam voucher!

🎁 🔥 Bonus Challenge: Push Copilot to Its Limits! 🔥
📝 Try these advanced tasks and report your findings:
🔹 Generate inline documentation for a function.
🔹 Ask Copilot to suggest an optimization for a slow algorithm.
🔹 Test Copilot's debugging suggestions—do they actually fix the issue?

Let’s collaborate, share insights, and push the boundaries of AI-assisted coding! 🚀

🙏 If there's any mistake, please forgive me. Let’s keep growing together! 😊

[Ronaldo-001]

Impressive!! @RAVINDRA8008

[paulsuv9]

Loving the energy, @RAVINDRA8008! 🎯 Prompt engineering is indeed a game-changer. I’ve found that being specific with prompts, like including performance constraints or expected output formats, really helps in getting better suggestions from Copilot. What’s been your biggest takeaway from this week’s focus on prompt engineering?

[mvark]

My key takeaway from the book 'Learn AI-Assisted Python Programming' is that in today's AI era, programming success (in any language) hinges on four skills:

• Problem decomposition
• Prompt engineering
• Reading code
• Testing and debugging

Reflecting on this point, I feel GitHub Copilot & AI code assistants are making the last 2 skills a piece of cake but the first two will keep humans relevant for a while.

[mvark]

Loving the pace at which nifty features are being introduced. GitHub Copilot chat now has additional options to switch to Claude 3.7 Sonnet & Claude 3.7 Sonnet Thinking

An interesting note on Version compatibility from the release notes -
_"As Copilot Chat releases in lockstep with VS Code due to its deep UI integration, every new version of Copilot Chat is only compatible with the latest and newest release of VS Code. This means that if you are using an older version of VS Code, you will not be able to use the latest Copilot Chat.

Only the latest Copilot Chat versions will use the latest models provided by the Copilot service, as even minor model upgrades require prompt changes and fixes in the extension. An older version of Copilot Chat will still use the latest version of Copilot completions."_

[Ronaldo-001]

Loving these updates! The flexibility to switch between Claude 3.7 Sonnet variants is awesome, and the version compatibility note is a great reminder to keep VS Code updated! 🚀

[mvark]

By default, Copilot code completion uses the GPT 3.5 Turbo large language model (LLM). There is a new code completion model, GPT-4o Copilot, which can now be enabled by VS Code users.

"This new model based on GPT-4o mini has additional training on over 275,000 high-quality public repositories in over 30 popular programming languages. As a result, you can expect this model to provide more accurate suggestions and to have better performance."

[VCharrua]

I've been using Claude 3.7 Sonnet these past few days to create a simple backend using Flask and sqllite3 exclusively through "GitHub Copilot Edits"... the improvements over version 3.5 are substantially noticeable.
And the possibility of recreating the project multiple times using different models has been an extremely interesting journey, especially when comparing the responses.

One question that @Akash1134 might be able to help answer is whether the various models were trained on the same datasets or different ones (mostly due to their release dates).
There are significant differences in the code generated from GPT and Claude models.

[Akash1134]

Week 4 - Testing, Security & Privacy : Copilot Free learning & cert prep is now Live 🚀

We’ve made it to the final week of this journey! After three weeks of hands-on learning and collaboration, it’s time to wrap up strong. Join us as we dive into testing, security, and privacy with GitHub Copilot—gain insights, sharpen your skills, and get ready to ace the certification.🔥

[GustavoBC2007]

Hi everyone! These are my answers for the 3rd week 👋
1. When using GitHub Copilot in a corporate environment, which of the following practices could introduce legal or security risks? (Select two)

Correct Answer ✅: A. Using Copilot to generate code for encryption algorithms without verification. C. Accepting Copilot-generated code that lacks licensing information.

Explanation ❓: Using Copilot for encryption without verification can lead to security vulnerabilities, and accepting code without licensing details may result in legal issues.

**2. A developer is working with Copilot in Visual Studio and wants to optimize Copilot’s inline chat for debugging. What is the best way to achieve this?

Correct Answer ✅: A. Rewriting prompts to be more detailed, explicitly mentioning expected outputs.

Explanation ❓: Providing detailed prompts helps Copilot generate more precise debugging suggestions.

3. A developer is using GitHub Copilot to generate a function for sorting a large dataset (100,000+ entries). Copilot suggests the following function:

Correct Answer ✅: C. The function does not use an in-place sorting method like data.sort().

Explanation ❓: In-place sorting methods like data.sort() are more memory-efficient for large datasets.

4. A developer asks Copilot to generate a function that computes Fibonacci numbers. The suggested function uses recursion but lacks memoization. What is the most likely reason for this omission?

Correct Answer ✅: C. Copilot lacks context about performance optimizations unless explicitly prompted.

Explanation ❓: Copilot generates standard implementations unless guided to prioritize performance improvements.

5. When using GitHub Copilot for SQL query generation, what should developers be cautious about?

Correct Answer ✅: B. Copilot might suggest queries vulnerable to SQL injection.

Explanation ❓: Developers should validate and sanitize user inputs to prevent SQL injection vulnerabilities.

6. A team is using Copilot for collaborative development. Developer A enables Copilot in a private repository. Developer B, working in the same repository, notices Copilot's suggestions contain code snippets that look unfamiliar. What might be happening?

Correct Answer ✅: B. Copilot is generating code based on patterns detected in the project’s existing files.

Explanation ❓: Copilot suggests completions based on the code present in the repository.

7. You request Copilot to generate a SQL query but notice that the suggested query lacks proper indexing considerations. What should you do?

Correct Answer ✅: A. Add a comment specifying performance constraints and indexing requirements.

Explanation ❓: Adding specific constraints helps Copilot generate more efficient queries.

8. A developer needs Copilot to generate optimized SQL queries. What prompt will yield the best results?

Correct Answer ✅: B. # Write an optimized SQL query that retrieves customer data using an index on customer_id.

Explanation ❓: Explicitly mentioning indexing ensures that the generated query is optimized for performance.

9. A team is developing a proprietary algorithm and wants to ensure Copilot does not suggest code similar to public implementations. What is the best approach? (Select two)

Correct Answer ✅: A. Use private repositories with Copilot to limit exposure to public code patterns. B. Explicitly describe unique constraints and design principles in inline comments.

Explanation ❓: Using private repositories and detailed comments reduces the likelihood of generating public-like code.

10. According to research on GitHub Copilot's impact, which of the following factors contribute most significantly to increased developer productivity when using Copilot? (Select two correct answers)

Correct Answer ✅: A. Reduction in the time spent searching for solutions on external websites. D. Faster onboarding of new developers due to AI-assisted code understanding.

Explanation ❓: Copilot helps developers by reducing external searches and accelerating onboarding.

11. Which of the following factors most significantly influence GitHub Copilot’s ability to generate high-quality completions? (Select two)

Correct Answer ✅: A. The recency of the training data used to build the model. B. The user's coding patterns and past accepted suggestions.

Explanation ❓: Copilot improves its suggestions based on recent training data and user interaction.

12. You are using GitHub Copilot in Visual Studio Code and notice that it frequently suggests outdated API methods that have been deprecated. What are the most effective strategies to improve the relevance of suggestions? (Select two)

Correct Answer ✅: A. Add a comment explicitly mentioning the latest API version before the function definition. B. Use natural language prompts that describe the intent of the code rather than function names.

Explanation ❓: Providing version details and clear intent helps Copilot generate up-to-date and relevant suggestions.

13. A developer is building a machine learning model in Python. They ask GitHub Copilot to generate a function for model training but notice that Copilot repeatedly suggests suboptimal hyperparameter choices. What is the best way to guide Copilot to generate better completions?

Correct Answer ✅: A. Use inline comments to specify preferred hyperparameters and model architectures.

Explanation ❓: Detailed comments ensure that Copilot aligns its suggestions with the developer’s requirements.

[VCharrua]

Unfortunately, I've been a bit absent the last few days... I recently took the Fabric Data Engineer Associate exam, which, along with some professional commitments, completely changed my ability to stay more active in this role (well, with some success, I passed the exam 🎉).

But since GitHub Copilot is currently my top priority, mastering this tool as quickly as possible is crucial for what I have planned for my upcoming projects.

So, I'm taking this opportunity to include my answers from week 3 and some of the principles behind my choices.

Knowledge Checkpoint

1. When using GitHub Copilot in a corporate environment, which of the following practices could introduce legal or security risks? (Select two)

• A) Using Copilot to generate code for encryption algorithms without verification.
• B) Enabling Copilot to suggest code completions within a private enterprise repository.
• C) Accepting Copilot-generated code that lacks licensing information.
• D) Using Copilot in an IDE that does not support secure API calls.

Explanation:

For answer A), using Copilot to generate code for encryption algorithms without verification can introduce security risks because the generated code might not follow best practices or might contain vulnerabilities. GitHub Copilot may generate syntactically correct code, but without expert verification, the implementation might contain subtle security vulnerabilities or cryptographic weaknesses. NIST and security experts recommend that cryptographic code always be verified by security professionals.

For answer C), accepting Copilot-generated code that lacks licensing information can introduce legal risks because it might violate software licensing agreements. Open-source licenses dictate how code can be used, modified, and distributed. Using code without understanding its license can lead to copyright infringement and legal disputes. Copilot may generate code that incorporates licensed snippets, and it's crucial to verify the licensing terms.

Sources:

• GitHub Docs: Security best practices
• GitHub Docs: Licensing a repository
• License for Copilot generated code #60304
• GitHub Docs: Trust Center

---

2. A developer is working with Copilot in Visual Studio and wants to optimize Copilot’s inline chat for debugging. What is the best way to achieve this?

• A) Rewriting prompts to be more detailed, explicitly mentioning expected outputs.
• B) Running Copilot Chat multiple times to get varied debugging suggestions.
• C) Adjusting Copilot’s temperature parameter to control randomness in responses.
• D) Restricting Copilot Chat to only use file-specific context rather than project-wide scope.

Explanation:

Copilot's effectiveness hinges on the clarity and specificity of the prompts it receives. Providing detailed prompts that clearly outline the desired behavior or expected output helps Copilot generate more relevant and accurate debugging suggestions.

Sources:

• Prompt engineering for Copilot Chat
• Introduction to prompt engineering with GitHub Copilot
• How to write better prompts for GitHub Copilot

---

3. A developer is using GitHub Copilot to generate a function for sorting a large dataset (100,000+ entries). Copilot suggests the following function:

def sort_data(data):
    return sorted(data)

Why might this function be suboptimal for large datasets?

• A) The sorted() function is not efficient for large datasets.
• B) The function lacks an explicit sorting algorithm, making it unpredictable.
• C) The function does not use an in-place sorting method like data.sort().
• D) Copilot might suggest a less efficient sorting algorithm if not prompted explicitly.

Explanation:

For answer C), Python's sorted() function creates a new list, which doubles memory usage - problematic for large datasets. The in-place data.sort() method is more memory-efficient as it doesn't create an extra copy of the data.

For answer D), without explicit prompts about performance requirements for large datasets, Copilot defaults to common patterns rather than optimized solutions. It may not consider memory constraints or time complexity unless specifically directed to generate code optimized for large data volumes.

Sources:

• Python sorting documentation
• How to write better prompts for GitHub Copilot

---

4. A developer asks Copilot to generate a function that computes Fibonacci numbers. The suggested function uses recursion but lacks memoization. What is the most likely reason for this omission?

• A) Copilot prioritizes standard implementations seen in open-source projects.
• B) Copilot avoids generating computationally expensive algorithms.
• C) Copilot lacks context about performance optimizations unless explicitly prompted.
• D) Copilot assumes the user will manually optimize the generated code.

Explanation:

For answer A), GitHub Copilot's training data includes many standard implementations of common algorithms like Fibonacci, and it tends to generate code similar to prevalent patterns in its training data. Simple recursive implementations are more common in educational contexts than optimized ones.

For answer C), without specific prompts mentioning performance concerns or the need for memoization, Copilot lacks the context to know that performance optimization is important for this particular implementation. When performance is a concern, explicit prompts about optimization techniques yield better results.

Sources:

• Getting code suggestions in your IDE with GitHub Copilot
• How to write better prompts for GitHub Copilot

---

5. When using GitHub Copilot for SQL query generation, what should developers be cautious about?

• A) Copilot always generates the most optimized query.
• B) Copilot might suggest queries vulnerable to SQL injection.
• C) Copilot does not support SQL query generation.
• D) Copilot automatically optimizes database indexes.

Explanation:

GitHub Copilot, trained on public repositories, may generate SQL code that uses string concatenation for query construction rather than parameterized queries. This approach can introduce SQL injection vulnerabilities if user inputs are not properly sanitized. Security best practices recommend always using parameterized queries or ORM frameworks to protect against injection attacks, and developers should review Copilot's SQL suggestions carefully for security issues.

Sources:

• Best practices for using GitHub Copilot
• OWASP SQL Injection Prevention

---

6. A team is using Copilot for collaborative development. Developer A enables Copilot in a private repository. Developer B, working in the same repository, notices Copilot's suggestions contain code snippets that look unfamiliar. What might be happening?

• A) Copilot is retrieving suggestions from similar open-source projects.
• B) Copilot is generating code based on patterns detected in the project’s existing files.
• C) Copilot is using external AI models to fetch relevant public code snippets.
• D) Copilot is applying prompt engineering techniques to infer missing logic.

Explanation:

GitHub Copilot considers the context of your current project, including code in other files, when generating suggestions. It may detect patterns, naming conventions, or architectural approaches used elsewhere in the project and incorporate them into suggestions, even if an individual developer hasn't seen that part of the codebase. This functionality helps maintain consistency across a project but can surprise developers unfamiliar with all parts of the codebase.

Sources:

• Documenting and explaining legacy code with GitHub Copilot: Tips and examples
• How GitHub Copilot is getting better at understanding your code

---

7. You request Copilot to generate a SQL query but notice that the suggested query lacks proper indexing considerations. What should you do?

• A) Add a comment specifying performance constraints and indexing requirements.
• B) Re-prompt Copilot with a more detailed query request.
• C) Accept the query and manually optimize it.
• D) Adjust Copilot’s model settings to prioritize efficiency.

Explanation:

For answer A), including detailed comments about performance requirements, database structure, and indexing information provides GitHub Copilot with crucial context it needs to generate optimized queries. Comments that outline expected execution plans or performance targets guide Copilot toward generating more efficient code.

For answer B), refining the prompt with specific details about performance expectations, table sizes, and indexing strategies can result in significantly improved SQL suggestions. Each interaction with Copilot builds upon previous context, allowing for iterative refinement of generated code.

Sources:

• Getting code suggestions in your IDE with GitHub Copilot
• Getting started with prompts for Copilot Chat
• How to write better prompts for GitHub Copilot
• Best practices for using GitHub Copilot

---

8. A developer needs Copilot to generate optimized SQL queries. What prompt will yield the best results?

• A) # Generate an SQL query to retrieve customer data.
• B) # Write an optimized SQL query that retrieves customer data using an index on customer_id.
• C) # Write an SQL query for fetching customer data using JOINs.
• D) # Generate a basic SQL query to fetch all rows from the customers table.

Explanation:

This prompt explicitly mentions optimization requirements and provides specific technical details about the indexing strategy. By including both the business requirement (retrieving customer data) and the technical constraint (using an index on customer_id), the prompt gives GitHub Copilot clear guidance on both what to accomplish and how to optimize it. This specificity helps Copilot generate code that aligns with performance best practices rather than just functional requirements.

Sources:

• How to write better prompts for GitHub Copilot

---

9. A team is developing a proprietary algorithm and wants to ensure Copilot does not suggest code similar to public implementations. What is the best approach? (Select two)

• A) Use private repositories with Copilot to limit exposure to public code patterns.
• B) Explicitly describe unique constraints and design principles in inline comments.
• C) Turn off Copilot suggestions for functions that contain proprietary logic.
• D) Modify Copilot's training dataset to exclude certain open-source projects.

Explanation:

For answer A), private repositories create an isolated development environment where Copilot's suggestions are influenced more by your team's code patterns than by public implementations. This helps maintain the uniqueness of proprietary algorithms by reducing the likelihood of suggestions that closely resemble open-source alternatives.

For answer B), detailed comments describing unique constraints, proprietary approaches, and specific design principles guide Copilot to generate suggestions aligned with your unique requirements rather than common patterns found in public code. This explicit guidance helps Copilot avoid defaulting to standard implementations.

Sources:

• Getting code suggestions in your IDE with GitHub Copilot

---

10. According to research on GitHub Copilot's impact, which of the following factors contribute most significantly to increased developer productivity when using Copilot? (Select two correct answers)

• A) Reduction in the time spent searching for solutions on external websites.
• B) Increased number of lines of code written per hour.
• C) A higher frequency of completed pull requests per developer.
• D) Faster onboarding of new developers due to AI-assisted code understanding.

Explanation:

For answer A), research shows that developers using GitHub Copilot spend significantly less time context-switching to search for solutions on sites like Stack Overflow or documentation pages. The ability to generate relevant code snippets directly in the IDE reduces this cognitive overhead and keeps developers in their flow state.

For answer D), studies indicate that new team members can more quickly understand existing codebases with Copilot's assistance. The AI can explain unfamiliar code, suggest implementations that match existing patterns, and provide context that would otherwise require extensive documentation reading or peer assistance.

Sources:

• Research: quantifying GitHub Copilot’s impact on developer productivity and happiness

---

11. Which of the following factors most significantly influence GitHub Copilot’s ability to generate high-quality completions? (Select two)

• A) The recency of the training data used to build the model.
• B) The user's coding patterns and past accepted suggestions.
• C) The number of times the user has prompted Copilot in a single session.
• D) Whether the user is working in an IDE or a browser-based editor.

Explanation:

The training data cutoff date significantly impacts GitHub Copilot's knowledge of newer APIs, frameworks, and programming practices. Models trained on more recent data can suggest code using the latest language features and library methods, while those with older training data may suggest deprecated approaches. This is particularly evident in rapidly evolving technologies where best practices change frequently. GitHub regularly updates Copilot models to incorporate newer training data and improve suggestion quality.

So, option A) because of Copilot's ability to suggest relevant, up-to-date code depends significantly on how recently its model was trained, particularly for rapidly evolving frameworks and libraries.

For option B), Copilot adapts to individual users over time, learning from which suggestions they accept or reject to provide more personalized and relevant completions.

Sources:

• Introduction to prompt engineering with GitHub Copilot
• Essentials of GitHub Copilot

---

12. You are using GitHub Copilot in Visual Studio Code and notice that it frequently suggests outdated API methods that have been deprecated. What are the most effective strategies to improve the relevance of suggestions? (Select two)

• A) Add a comment explicitly mentioning the latest API version before the function definition.
• B) Use natural language prompts that describe the intent of the code rather than function names.
• C) Adjust the settings to restrict Copilot to suggestions from private repositories only.
• D) Revert to an older version of GitHub Copilot that was trained on previous API versions.

Explanation:

For answer A), explicit comments about API versions guide Copilot to use up-to-date methods and avoid deprecated ones. This provides specific context for the model.

For answer B), intent-based prompts focus on what the code should accomplish rather than how it should be implemented, allowing Copilot to suggest modern approaches.

Sources:

• How to use GitHub Copilot: Prompts, tips, and use cases
• Prompt engineering for GitHub Copilot

---

13. A developer is building a machine learning model in Python. They ask GitHub Copilot to generate a function for model training but notice that Copilot repeatedly suggests suboptimal hyperparameter choices. What is the best way to guide Copilot to generate better completions?

• A) Use inline comments to specify preferred hyperparameters and model architectures.
• B) Accept a Copilot suggestion and manually tweak the parameters later.
• C) Change the function name to include terms like “optimized” or “efficient.”
• D) Train Copilot on previous successful models to improve its suggestions.

Explanation

Detailed inline comments that specify hyperparameters, architectures, and optimization techniques provide Copilot with the specific context needed to generate more appropriate machine learning code.

Source

• Prompt engineering for GitHub Copilot

---

I'm also working on a GenAI project using GitHub Copilot which I'll detail in future posts. 🚀🚀🚀

[VCharrua]

Summary of the Importance of Prompt Engineering and Productivity with GitHub Copilot

This week content focuses on core principles of prompt engineering and developer productivity with GitHub Copilot, which is important for several key reasons:

Enhancing Developer Efficiency

Mastering prompt crafting and engineering allows developers to effectively communicate their needs to GitHub Copilot, resulting in more accurate code suggestions that require less manual refinement. This significantly reduces development time and cognitive load, allowing developers to focus on solving complex problems rather than writing routine code.

Optimizing the Software Development Life Cycle (SDLC)

Understanding how GitHub Copilot fits into various SDLC stages enables teams to strategically leverage AI assistance throughout the development process. From initial code generation to testing and refactoring, effective prompting helps accelerate all aspects of software development while maintaining quality standards.

Acknowledging Limitations

Recognizing GitHub Copilot's limitations is crucial for responsible implementation. By understanding where AI assistance excels and where human oversight remains essential, developers can establish appropriate guardrails and verification processes to ensure code quality, security, and compliance with organizational standards.

Measuring Impact

Learning to use productivity APIs to quantify GitHub Copilot's impact provides organizations with concrete data to assess ROI and optimize implementation strategies. These metrics help justify AI adoption and identify areas where further training or refinement of prompting techniques could yield additional benefits.

Overall, mastering these concepts allows developers and organizations to harness the full potential of AI-assisted coding while maintaining control over the development process, resulting in faster delivery, higher code quality, and more innovative solutions.

🚀🚀🚀