Search
8 results for “few-shot”
Search results
Prompt Engineering
Why a role set in the system prompt shapes every response differently than the same instruction in a user message, and why 3-5 well-chosen examples reliably steer output format better than more instructions alone.
What does putting an instruction in the system prompt actually change versus putting the same instruction in the first user message?
A system prompt sets standing context and role for the entire conversation, "you are a helpful coding assistant specializing in Python," and that framing persists and shapes tone and behavior across every subsequent turn without needing to be repeated. The same sentence placed in a user message is treated as part of the conversational exchange itself, mixed in with whatever else that turn asks for, rather than as a persistent behavioral frame the model treats as instruction-level context throughout the session. Even a single well-chosen sentence in the system prompt measurably changes tone and focus, which is why role-setting belongs there rather than being re-stated per turn.
Why does official prompting guidance recommend 3-5 examples specifically, and what makes an example actually useful versus counterproductive?
Few-shot (multishot) examples are one of the most reliable levers for steering output format, tone, and structure, and guidance specifically recommends 3-5 well-chosen examples for best results, few enough to stay practical, enough to establish a real pattern rather than one potentially misleading instance. What makes an example useful is being relevant (mirroring the actual use case closely), diverse (covering edge cases so the model doesn't latch onto an incidental, unintended pattern from too-similar examples), and structured (wrapped in clear tags so the model can distinguish example content from the surrounding instructions). A single example, or several near-duplicate ones, risks teaching an accidental pattern instead of the intended one.
What problem does wrapping different parts of a prompt in XML-style tags actually solve?
A complex prompt often mixes several genuinely different kinds of content in one block of text, instructions, background context, few-shot examples, and the actual variable input to process, and a model has to infer where one ends and the next begins from phrasing alone if nothing marks the boundaries. Wrapping each kind of content in its own consistently-named tag, `<instructions>`, `<context>`, `<example>`, `<input>`, removes that inference step entirely: the structure itself tells the model unambiguously what role each piece of text plays, which reduces misinterpretation especially as a prompt grows longer or nests multiple documents or examples.
A custom dropdown built entirely from styled divs passes a visual design review. What is likely still broken for a keyboard-only or screen-reader user, and why doesn't looking right catch it?
Without the correct ARIA roles/states (or, better, a native `<select>`), a div-based dropdown typically has no way to be reached or operated via keyboard alone (no built-in Tab/Enter/Arrow-key handling), and a screen reader has no semantic information telling it "this is a dropdown, it is currently closed, here are its options," so it may announce nothing meaningful at all. A purely visual review can't catch this because the div looks and behaves correctly with a mouse, the missing behavior only surfaces via keyboard navigation or assistive technology, which is exactly why accessibility has to be tested directly with a keyboard and a screen reader, not inferred from how a component looks.
A query filters WHERE logdate >= 2008-01-01 against a table range-partitioned by logdate across dozens of monthly partitions. What does partition pruning actually do, and what does it depend on?
Partition pruning lets the planner prove, from the query's WHERE clause and each partition's declared bounds, that some partitions cannot possibly contain a matching row, and it excludes them from the plan entirely rather than scanning and filtering every partition. In this example, `logdate >= 2008-01-01` has no upper bound, so it prunes only the partitions entirely before 2008-01, decades of older monthly partitions are eliminated before execution, while every partition from 2008-01 onward, including all of them up to the present, is still considered and scanned. Pruning down to a single partition would need a bounded predicate on both ends, for example `logdate >= 2008-01-01 AND logdate < 2008-02-01`. This depends entirely on the partition bounds themselves, not on any index, a partitioned table with no indexes at all still benefits from pruning, and pruning specifically requires the WHERE clause to reference the partition key directly with values (or parameters) the planner can actually compare against those bounds.
What is the practical difference between ps -ef and ps aux, and why do they show different columns for the same processes?
`-ef` is UNIX-style syntax and `aux` is BSD-style syntax for the same underlying command, and they weren't designed as one consistent interface; mixing them can even be ambiguous depending on other options used. The manual is explicit that BSD-style options change the default output to include process state (STAT) and full command arguments (COMMAND) instead of just the executable name, and BSD-style selection also defaults to showing every process the invoking user owns across all terminals, while UNIX-style selection defaults to processes on the current terminal only. Neither is "more correct," they're two different historical option conventions layered onto the same command, which is why picking one and being consistent about it matters more than which one.
A page has a fast average LCP but users still frequently report the page feeling slow. What could the percentile-based measurement reveal that an average wouldn't?
If a substantial slice of real page loads, say the slowest 25%, badly miss the 2.5 second LCP threshold (a slow connection, a busy device, a cold cache), the average can still look fine because it's dominated by the faster majority, while a real, sizable group of users are having a genuinely bad experience the average is actively hiding. Checking the 75th-percentile value directly (rather than the mean) surfaces that gap: if the 75th percentile is well above 2.5 seconds even though the average looks fine, that's a concrete signal that meaningful numbers of real users are missing the threshold, not a false alarm.