Create prompt-drills.md

Add prompt drills exercise.

Author: EficodeRjpalt

prompt-drills.md

@@ -0,0 +1,139 @@
+## GitHub Copilot Hackathon Extended Drilling Exercises (Up to 60 Minutes - Adjust as Needed)
+
+This extended set of exercises will further explore GitHub Copilot's capabilities within VS Code. Aim to spend roughly 1-2 minutes on simpler exercises and 2-3 minutes on more complex ones.
+
+**Setup:**
+
+1.  ✅ Open Visual Studio Code.
+2.  ✅ Ensure you have the GitHub Copilot extension installed and are logged in.
+3.  ✅ Open an existing code project (or create a more substantial one with multiple files, functions, and potentially some comments for better exploration).
+
+**Exercises:**
+
+1.  ✅ **Exploring Basic In-line Suggestions:** (Same as before - Reinforce the basics)
+    * Start typing common code structures. Observe and accept/ignore suggestions.
+
+2.  ✅ **Getting Alternative In-line Suggestions:**
+    * Type some code and wait for an in-line suggestion.
+    * Press `Ctrl+Enter` (or `Cmd+Enter` on macOS) to open the Copilot window with alternative suggestions.
+    * Browse through the alternatives and select one you like.
+    * **Goal:** Learn how to access and choose from multiple in-line suggestions.
+
+3.  ✅ **Understanding Codebase with `@workspace /explain` (Revisited):** (Same as before - Emphasize on a more complex part of the codebase)
+    * Use `@workspace /explain` on a more intricate section of your code.
+
+4.  ✅ **Generating Diagrams with `@workspace` (More Specific):**
+    * Use `@workspace /diagram` with more specific instructions (e.g., "Show the data flow for the user registration process.", "Create a component diagram for the main modules.").
+
+5.  ✅ **Generating Unit Tests with `#selection` (Multiple Scenarios):**
+    * Select different types of code (e.g., a function with conditional logic, a class method) and use `#selection write unit tests`.
+    * **Goal:** See how test generation adapts to different code structures.
+
+6.  ✅ **Targeting Codebase Understanding with `@workspace #folder /explain` (Multiple Folders):**
+    * Try using `@workspace #folder` with different folders in your project to understand their respective roles.
+
+7.  ✅ **Referencing a Specific File with `@workspace #file /explain` (Different File Types):**
+    * Use `@workspace #file` to ask questions about different types of files in your project (e.g., configuration files, data structures).
+
+8.  ✅ **Referencing a Specific Function with `@workspace #sym /explain` (Complex Functions):**
+    * Select a function with more complex logic or multiple nested calls and use `@workspace #sym /explain`.
+
+9.  ✅ **Generating Documentation with Selection (Different Levels of Detail):**
+    * Select code and try prompts like `Write a concise documentation summary for #selection` and `Write detailed JSDoc-style documentation for #selection`.
+    * **Goal:** Explore different levels of documentation generation.
+
+10. ✅ **Generating Tests with Selection (Edge Cases):**
+    * Select a function and try prompting `Generate unit tests for #selection including edge cases and error handling.`.
+    * **Goal:** See if Copilot can anticipate and generate tests for less common scenarios.
+
+11. ✅ **Reviewing Code with Selection (Specific Focus):**
+    * Select code and try prompts like `Review #selection for potential security vulnerabilities.` or `Review #selection for code style consistency.`.
+    * **Goal:** Learn to guide the code review process with specific concerns.
+
+12. ✅ **Using `#terminalLastCommand` for Contextual Help:**
+    * Execute a command that resulted in an error in the terminal.
+    * In the chat, type: `#terminalLastCommand What caused this error and how can I fix it?`.
+    * **Goal:** See how terminal output can be used for debugging assistance.
+
+13. ✅ **Discussing VS Code with `@vscode` (Settings and Features):**
+    * Ask `@vscode` about specific settings (e.g., "How do I enable word wrap?") or features (e.g., "Explain how the debugger works in VS Code.").
+
+14. ✅ **Generating Code with In-line Chat (Specific Task):**
+    * In a code file, type a comment describing a small code snippet you want to generate (e.g., `// Function to calculate the factorial of a number`).
+    * Observe the in-line suggestions and accept a suitable one.
+    * **Goal:** Practice using comments to guide in-line code generation.
+
+15. ✅ **Refactoring Code with In-line Chat:**
+    * Select a piece of code that could be improved (e.g., a long function).
+    * In the in-line chat (after selecting), type: `Refactor this code to be more readable.` or `Extract this logic into a separate function.`.
+    * **Goal:** Explore Copilot's ability to suggest and perform basic refactoring.
+
+16. ✅ **Explaining Code with In-line Chat:**
+    * Select a line or block of code you want to understand.
+    * In the in-line chat (after selecting), type: `Explain this code.` or `What does this line do?`.
+    * **Goal:** Quickly get explanations for unfamiliar code snippets.
+
+17. ✅ **Generating Code Snippets with Chat (More Complex):**
+    * In the Copilot Chat, describe a more complex code snippet you need (e.g., "Write a Python function that reads data from a CSV file and returns a list of dictionaries.").
+    * **Goal:** Practice using the chat for generating larger and more specific code blocks.
+
+18. ✅ **Asking Follow-up Questions in Chat:**
+    * After Copilot provides a response in the chat, ask a follow-up question to refine the answer or explore related topics.
+    * **Goal:** Understand the iterative nature of interacting with Copilot.
+
+19. ✅ **Using `@workspace` to Find Code:**
+    * In the Copilot Chat, type: `@workspace Find all occurrences of the function named 'processData'.`.
+    * **Goal:** Learn how to use `@workspace` for code search within your project.
+
+20. ✅ **Generating Code Based on Examples in Chat:**
+    * Provide a small example of the code you want (e.g., "I want a function that takes a list of strings and returns a new list with the length of each string. For example, ['apple', 'banana'] should return [5, 6].").
+    * Then ask Copilot to generate the function.
+    * **Goal:** See how providing examples can guide code generation.
+
+21. ✅ **Using `#selection` for Code Transformation:**
+    * Select a block of code and ask Copilot to transform it (e.g., `Convert #selection from JavaScript to Python.`, `Make #selection use arrow functions.`).
+    * **Goal:** Explore basic code transformation capabilities.
+
+22. ✅ **Generating Comments for Existing Code:**
+    * Select a block of uncommented code and ask Copilot to `Add comments to #selection explaining the logic.`.
+    * **Goal:** See how Copilot can help improve code readability through comments.
+
+23. ✅ **Asking About Best Practices with `@workspace`:**
+    * In the chat, ask: `@workspace What are some best practices for error handling in this project?` or `@workspace Suggest ways to improve the performance of this module.`.
+    * **Goal:** Leverage `@workspace` for getting advice on code quality and best practices within your codebase.
+
+24. ✅ **Using In-line Chat for Quick Modifications:**
+    * Select a variable name and use the in-line chat to ask: `Rename this variable to 'itemCount'.`.
+    * **Goal:** Practice using in-line chat for small, focused code modifications.
+
+25. ✅ **Exploring Different In-line Suggestion Styles:**
+    * Type code in different styles (e.g., verbose vs. concise) and observe how Copilot's suggestions adapt.
+    * **Goal:** Understand the influence of your coding style on Copilot's suggestions.
+
+26. ✅ **Using `@workspace` to Understand Project Structure:**
+    * In the chat, ask: `@workspace Describe the overall architecture of this project.` or `@workspace What are the main modules and their dependencies?`.
+    * **Goal:** Use `@workspace` to get a high-level understanding of your project's organization.
+
+27. ✅ **Generating Data Structures with Chat:**
+    * In the chat, describe the data structure you need (e.g., "Generate a JSON object representing a customer with properties for name, email, and address.").
+    * **Goal:** Practice generating data structures using natural language in the chat.
+
+28. ✅ **Asking for Explanations of Technical Concepts:**
+    * Use the Copilot Chat to ask general programming questions (e.g., "What is the difference between synchronous and asynchronous programming?", "Explain the concept of recursion.").
+    * **Goal:** Utilize Copilot as a learning resource for technical concepts.
+
+29. ✅ **Combining `#file` and `#sym` for Focused Questions:**
+    * In the chat, type: `@workspace #file:<path/to/your/file.js> #sym:<name_of_a_function_in_that_file> What are the potential side effects of this function?`.
+    * **Goal:** See how combining `#file` and `#sym` allows for very precise questions.
+
+30. ✅ **Experimenting with Creative Prompts:**
+    * Try using more open-ended or creative prompts in the chat (e.g., "Write a short poem about this code.", "Suggest three alternative ways to implement this feature.").
+    * **Goal:** Explore the more imaginative capabilities of Copilot.
+
+**Wrap-up:**
+
+* ✅ Discuss which new commands and techniques were most insightful.
+* ✅ Encourage participants to continue exploring the documentation and experimenting with different prompts.
+* ✅ Emphasize the importance of providing clear and specific prompts for the best results.
+
+This expanded set of exercises should provide a more comprehensive exploration of GitHub Copilot's features within VS Code, drawing directly from the provided documentation. Remember to adjust the time allocated for each exercise based on the participants' pace and the complexity of the tasks.