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

[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.

[mvark]

My entry for the GitHubCopilotChallenge - NutriScan, a minimalist web application that turns your mobile browser into a barcode scanner and tells you whether a packaged food item is Ultra-Processed or not. No dedicated smartphone app is required unlike other scanning apps; it runs with just HTML and JavaScript!

JavaScript has changed significantly in the last decade. Many of the features that were part of helper libraries like jQuery are now included natively. As I wanted the app to load very fast, GitHub Copilot generated lean code and GitHub Copilot Chat explained the code where I needed help in understanding.

Overview
NutriScan allows you to scan a product barcode using your smartphone's camera and then redirects you to the corresponding product's page on Open Food Facts to display nutrition information.

Open Food Facts is the world's largest open source food database, a sort of Wikipedia of Food. Nutrition information for more than 3.6 million products is available on the OFF website. You can access this data through their website, API, or as a data dump.

Open Food Facts employs a nutritional rating system that rewards products rich in beneficial nutrients like fiber and protein, while penalizing those high in less desirable components such as fats, sugars, and sodium.

I'm an active contributor to the Open Food Facts database and I highly encourage like-minded people to add missing data.

My sample code scans an EAN-13 barcode from a packaged food product and then fetches its:

• Name
• Image
• Nutri-Score giving an indication of the nutritional quality of a food item
• Nova classification assigning foods a score from 1 to 4 — where 1 represents unprocessed foods and 4 denotes ultra-processed foods
• using the Open Food Facts REST API.

How to Use

• Access the Web App: Open the NutriScan web page in your mobile browser.
  

• Scan Barcode: The app will request access to your device's camera. Grant permission and scan the barcode of a packaged food product.

• View Information: The app will display the product's name, image, Nutri-Score, and Nova grouping.
  

Key Features

• Barcode Scanning: Utilises Minhaz's open-source HTML5 QR Code & Barcode Scanner JavaScript library to access a mobile device's camera and scan barcodes directly within the browser.
• Open Food Facts Integration: Redirects to Open Food Facts to display detailed nutrition information for the scanned product or fetches product details via the Open Food Facts REST API.
• Minimalist Design: The code is deliberately kept lean to demonstrate the minimum amount of code required for a functional app.
• Low Data Transfer: The total data transferred to and from the app is less than 400kb.
• No App Required: Eliminates the need for users to install a dedicated barcode scanner app.

Code Structure
The repository includes:

• HTML file with the basic structure of the web page. It includes JavaScript code to handle camera access, barcode scanning, and data retrieval from Open Food Facts.
• The code for the JavaScript file html5-qrcode.min.js can be copied from Minhaz's GitHub repository, which hosts the HTML5 QR Code & Barcode Scanner JavaScript library.

Troubleshooting
During development I discovered that there were instances where nova_group and nutriscore_grade fields in the JSON were missing from the API response. This was causing an error. With the help of GitHub Copilot & remote debugging through the Android device, I identified & fixed the issue.

I've also added "Thing Near Me" the other app I co-created with Copilot to the repo WebApps. I plan to add more code samples as I continue exploring interesting public REST APIs.

[paulsuv9]

Excellent work on the NutriScan app, @mvark! The minimalist design is impressive. One area for improvement could be adding more error handling for missing API fields.

[Ronaldo-001]

So cool project!! @mvark

[Parthapnath]

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

[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]

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]

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.

[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. 😊

[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

[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."

[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.🔥