Prompt Engineering: Zero-shot, One-shot, Few-shot Techniques Explained (Practical Implementation)

Prompting lets a pre-trained language model follow tasks using only instructions and examples—no weight updates—so performance can be improved by moving from zero-shot to one-shot to few-shot prompting. The core takeaway is that adding a small number of in-context examples meaningfully raises output quality, and the transcript demonstrates this using dialog summarization with a flan-T5 model.

The discussion starts by contrasting prompting with fine-tuning. Prompting works by feeding an LLM a task description plus optional context; the model generates output using its existing knowledge without changing parameters or weights. Its main advantages are speed and flexibility: users can adapt to new tasks quickly by rewriting prompts, without retraining. The tradeoffs are weaker performance when the task/domain is unfamiliar and a dependence on prompt quality—complex tasks often require careful experimentation.

Fine-tuning, by contrast, retrains the model on task-specific data, updating parameters through gradient-based learning. That specialization can improve performance on targeted domains (the transcript gives legal-document handling as an example), but it comes with costs: additional compute and time, plus risks like overfitting when datasets are small or overly narrow. The transcript frames the key differences as: prompting keeps model parameters fixed while fine-tuning updates them; prompting is dynamic and general-purpose while fine-tuning is targeted; prompting is cheaper and faster but lower-performing overall, while fine-tuning is more expensive but can deliver stronger task-specific results.

To ground the prompting concepts, the transcript then walks through traditional fine-tuning at a high level: the model trains on example input-output pairs, computes errors, applies gradient updates, repeats across many examples, and gradually improves its ability to generate correct responses.

The practical implementation section focuses on prompting methods using Google Colab. It installs and imports Hugging Face libraries (datasets and Transformers), loads a dialog dataset from Hugging Face that includes dialogues and baseline human summaries, and uses flan-T5 base with its tokenizer. The notebook demonstrates tokenization (string-to-token IDs and back) and then runs summarization in three prompting regimes.

In zero-shot prompting, the model receives only an instruction such as “Please summarize in the three lines” along with the dialogue. No example pairs are provided, and no gradient updates occur. The resulting summaries are generally on-task but differ in phrasing and focus from the dataset’s baseline summaries.

In one-shot prompting, the prompt includes the task instruction plus a single dialogue-summary example before asking the model to summarize a new dialogue. The transcript notes that this extra example makes outputs more acceptable and closer to the baseline style.

In few-shot prompting, the prompt includes multiple examples (three in the described setup) before summarizing a new dialogue. With more demonstrations in-context, the flan-T5 model produces higher-quality summaries, and the transcript explicitly reports an improvement as the method progresses from zero-shot to one-shot to few-shot.

Overall, the transcript positions in-context learning as a practical alternative to fine-tuning: it avoids retraining while still improving results through better prompt construction and additional examples.