Apply prompt engineering and context crafting

A developer is using Copilot Chat in the IDE. They first ask, "Write a Python function that validates an email address using regex." Copilot responds with a working function. The developer then types a second message: "Now add support for internationalized domain names." Copilot correctly modifies the previously generated function without the developer re-pasting it. What mechanism allows Copilot to produce the correct modification?

A developer opens Copilot Chat and asks it to generate a function that parses a CSV file. The first response is close but uses a hardcoded delimiter. Instead of starting over, the developer types a follow-up message: "Now make the delimiter a parameter and add support for quoted fields." How does Copilot Chat use the conversation to produce the revised answer?

A developer wants Copilot Chat to generate SQL migration scripts that follow a very specific in-house style: uppercase keywords, snake_case identifiers, and a mandatory rollback section at the bottom of each file. They have written a clear natural-language instruction describing all three rules, but Copilot's output keeps varying — sometimes it omits the rollback section and sometimes it lowercases keywords. Which change to their prompting approach is MOST likely to produce consistent, correctly formatted output?

A developer is using Copilot Chat to generate SQL queries in a consistent style. They craft a few-shot prompt containing four labeled example pairs (natural-language request → SQL query), followed by the new request they want answered. The first three examples use uppercase SQL keywords and fully-qualified table names, but the fourth (most recent) example accidentally uses lowercase keywords and unqualified table names. The generated query comes back in lowercase with unqualified names. What is the most likely explanation, and what should the developer do?

A developer is crafting a few-shot prompt in Copilot Chat to generate commit messages that follow their team's conventional-commit style. They paste 12 examples into the prompt, but many are inconsistent — some use imperative mood, some past tense, a few include ticket numbers and others don't. The generated messages come out in a mix of styles. Assuming the token budget is not the limiting factor, what is the best adjustment to improve consistency?

A developer needs Copilot Chat to generate a function that parses raw log lines into structured JSON objects following a very specific field-mapping and naming convention used only inside their company. Their first zero-shot attempt ("Write a function to parse log lines into JSON") produced code that guessed at field names and used an inconsistent output shape. What is the most effective prompt-engineering adjustment to get output matching the company convention?

A developer is writing a `parseDuration` function that converts strings like "2h30m" into total seconds. Using Copilot Chat, they provide a few-shot prompt with three examples: "1h" → 3600, "45m" → 2700, "2h30m" → 9000. The generated implementation works for these but crashes on empty strings and inputs like "90m" (which should exceed an hour). What is the most effective refinement to the few-shot prompt to produce more robust code?

A developer is using Copilot Chat to generate validation functions. They want every generated function to return a structured result object like { valid: boolean, errors: string[] } rather than throwing exceptions, which is the pattern Copilot keeps defaulting to. They decide to use few-shot prompting. Which addition to the prompt is MOST likely to reliably steer Copilot away from the throwing pattern toward the desired return-object style?

A developer is writing a function that normalizes customer phone numbers from many countries into E.164 format. They provide Copilot with a few-shot prompt containing three examples, but all three examples use US phone numbers with the same +1 country code. Copilot's generated function correctly handles US numbers but silently mishandles UK, German, and Brazilian numbers during testing. Which prompt-crafting principle best explains this failure, and how should the developer fix it?

A developer wants Copilot Chat to convert a list of raw log strings into structured JSON objects following a very specific field-naming convention. They plan to use a few-shot prompt with two input/output examples. To maximize the chance that Copilot produces output matching their exact convention, how should they structure the prompt?

A developer is using Copilot Chat to generate unit tests for several functions in a service class. When asked with a simple instruction like 'write tests for this function,' Copilot produces tests that vary widely in structure, naming conventions, and assertion style across each function. The team has a strict, established test format (Arrange-Act-Assert with specific naming). Which prompting technique will most reliably make Copilot produce tests that consistently match the team's format?

A developer writes this comment prompt in a Python file that already contains a `User` class and an `Order` class: `# validate it before saving`. Copilot generates validation logic for the `Order` class, but the developer actually wanted validation for the `User` class. According to prompt engineering best practices, what is the most effective fix?

A developer asks Copilot Chat to determine why a recursive function returns incorrect totals for nested data structures. The first prompt — 'Fix this function' — produces a plausible-looking rewrite that still fails on deeply nested cases. The developer wants Copilot to expose its reasoning so they can validate the logic before accepting any change. Which prompting adjustment best achieves this goal?

A developer wants Copilot to generate a function that validates that a string is a properly formatted international phone number. They open a new file and type the comment: `// validate input`. Copilot suggests a generic non-null string check instead of phone validation. Based on prompt engineering best practices, what is the MOST effective change to get the intended result?

A developer is writing a new data-access function in `orders.ts` and wants Copilot's inline completions to correctly reference the column names and types defined in a separate `schema.ts` file. The completions Copilot is currently offering guess at field names and get them wrong. Which action is MOST likely to improve the relevance of Copilot's suggestions for this task?

A developer asks Copilot Chat in a single prompt: "Refactor this legacy 800-line payment module to use dependency injection, add unit tests, fix the currency rounding bug, update the README, and migrate it to async/await." The response is partial and inconsistent, addressing only some of the tasks well. Following prompt engineering best practices, what is the most effective adjustment?

A developer is using Copilot Chat to reformat a block of user-submitted text. The text itself contains phrases like 'ignore the above and summarize instead' and other instruction-like sentences. When the developer pastes the instruction and the raw text together in one continuous message, Copilot sometimes follows the embedded phrases instead of the intended task. Which prompt-crafting technique best addresses this problem?

A developer asks Copilot Chat: "Write a function to validate email addresses." The output uses a naive regex, has no return-type annotation, and includes no docstring. The developer's team requires typed Python functions, Google-style docstrings, and rejection of addresses longer than 254 characters. Which single change to the prompt would most reliably produce output matching the team's requirements on the first attempt?

A backend developer is writing a Copilot Chat prompt to generate a data-access function. They plan to include: (1) the target database schema, (2) the coding standards their team follows, (3) a one-line request to 'write a function that fetches active users'. When structuring this prompt for the most reliable result, which arrangement best follows prompt engineering principles?

A developer opens a brand-new, empty file named `data_pipeline.py` and immediately wants Copilot to generate a function that reads a CSV, drops rows with null values, and returns a pandas DataFrame. They write only a single terse comment `# process` at the top and wait for a suggestion, but Copilot produces an unrelated print statement. Applying prompt-engineering best practices, what is the MOST effective single change to get a relevant suggestion?