Few-Shot Prompting Patterns

Lesson 1 covered instructions, telling a model what to do in words. This lesson covers showing it instead, giving the model two or three worked examples of exactly the kind of input and output you want, before it ever sees the real one. That’s few-shot prompting, and for tasks with a specific, repeatable output style, meta descriptions, excerpt formatting, tag naming conventions, it’s often more reliable than any amount of extra wording in a system instruction. with_history() is the builder method that makes this possible, and this lesson builds a real few-shot setup for generating consistent SEO meta descriptions.

Step 1: Why examples work when instructions alone don’t

A system instruction can describe a rule, “keep it under 155 characters, active voice, no clickbait phrasing,” but “active voice” and “no clickbait phrasing” are judgment calls, and a model asked to follow a judgment call in words alone will interpret it inconsistently across different inputs. Showing two or three examples of input content paired with the exact output style you want removes most of that ambiguity, the model now has a concrete pattern to match rather than a description to interpret.

Step 2: How with_history() actually works

with_history() takes a list of prior messages and prepends them to the conversation, before the current prompt you build with with_text(). Each message has a role, either a user turn or a model turn, and the pattern for few-shot prompting is straightforward: alternate a user message showing sample input with a model message showing the exact output you want for it, repeated for each example, then your real input follows as the final, un-answered turn.

// File: my-plugin/class-meta-description-generator.php
use WordPress\AiClient\Messages\DTO\MessagePart;
use WordPress\AiClient\Messages\DTO\UserMessage;
use WordPress\AiClient\Messages\DTO\ModelMessage;

$few_shot_history = array(
	new UserMessage( array( new MessagePart(
		'Post title: How to Prune Tomatoes for a Bigger Harvest. ' .
		'Content summary: step-by-step pruning technique for indeterminate tomato ' .
		'plants, covers suckers, timing, and tools.'
	) ) ),
	new ModelMessage( array( new MessagePart(
		'Learn the exact pruning technique that increases tomato yield, ' .
		'covering suckers, timing, and the right tools.'
	) ) ),

	new UserMessage( array( new MessagePart(
		'Post title: WordPress 7.0 Block Editor Changes. ' .
		'Content summary: overview of new block editor features shipping in ' .
		'WordPress 7.0, aimed at theme developers.'
	) ) ),
	new ModelMessage( array( new MessagePart(
		'A theme developer\'s overview of the block editor changes shipping in ' .
		'WordPress 7.0.'
	) ) ),
);

Step 3: Running the real input through the same shape

The final call adds the real post as the current prompt, after the example history, and keeps the system instruction from Lesson 1’s pattern for the parts examples can’t cover on their own, the hard character limit in particular:

// File: my-plugin/class-meta-description-generator.php
$response = wp_ai_client_prompt()
	->using_system_instruction(
		'Write a single SEO meta description, 150 to 155 characters, active voice, ' .
		'no clickbait, no quotation marks around the result.'
	)
	->with_history( ...$few_shot_history )
	->with_text(
		'Post title: Setting Up a Staging Site With WP-CLI. ' .
		'Content summary: creating an isolated staging copy of a WordPress site ' .
		'using wp-cli commands, for testing plugin updates safely.'
	)
	->using_temperature( 0.3 )
	->generate_text();

Notice the system instruction still carries the one rule examples handle poorly, an exact character count, since counting characters isn’t a pattern a model reliably infers from two examples alone. Few-shot examples and a system instruction aren’t competing techniques, they cover different kinds of constraints and work best stacked together, exactly as they are here.

Step 4: How many examples is enough

Two or three well-chosen examples cover most WordPress content-generation tasks. Each example adds tokens to every single call, which is real, recurring cost, not a one-time setup cost, so more examples isn’t automatically better. If two examples aren’t producing consistent output, the more likely fix is that the examples themselves are inconsistent with each other, not that a third or fourth example will resolve it.

Test it: run the meta description generator

wp-env run cli wp eval '
$title = "Setting Up a Staging Site With WP-CLI";
$summary = "Creating an isolated staging copy of a WordPress site using wp-cli commands, for testing plugin updates safely.";

echo wp_ai_client_prompt()
	->using_system_instruction(
		"Write a single SEO meta description, 150 to 155 characters, active voice, " .
		"no clickbait, no quotation marks around the result."
	)
	->with_text( "Post title: $title. Content summary: $summary." )
	->using_temperature( 0.3 )
	->generate_text();
'

Run it once with only the system instruction, then add the with_history() few-shot set from Step 2 and run it again. You should see the few-shot version land more consistently in the 150 to 155 character range and match the tone of the two examples more closely than the instruction-only version does.

Recap

Few-shot prompting works by showing a model examples instead of only describing rules, and with_history() is the builder method that prepends those example turns before your real prompt. Build history as alternating user and model messages using UserMessage, ModelMessage, and MessagePart, keep examples consistent with each other and representative of real production input, and stack few-shot history with a system instruction rather than treating them as alternatives, since each covers constraints the other handles poorly.

Resources & further reading

• PHP AI Client SDK repository, GitHub
• Introducing the AI Client in WordPress 7.0, make.wordpress.org
• Introducing the WordPress AI Client SDK, make.wordpress.org