Prompt strategies

Temperature guide

Workflow

Step 1: Define the task contract

Before writing any prompt, answer these questions:

type PromptContract = {
  input: string;       // What does the model receive?
  output: string;      // What should it produce?
  format: string;      // JSON, markdown, plain text?
  constraints: string[]; // What must it avoid?
  edgeCases: string[];   // How should it handle ambiguity?
  examples: Array<{ input: string; output: string }>;
};

Step 2: Write the system prompt

const systemPrompt = \`You are a senior code reviewer specializing in TypeScript and React.

## Task
Review the provided code diff and return structured feedback.

## Output format
Return a JSON array of findings:
[
  {
    "severity": "critical" | "warning" | "info",
    "line": <number>,
    "message": "<concise description>",
    "suggestion": "<specific fix>"
  }
]

## Rules
- Focus on bugs, security issues, and performance problems
- Do not comment on style preferences unless they cause bugs
- If the code is correct and well-written, return an empty array []
- Never suggest changes that would break existing tests
- Limit findings to the top 5 most important issues

## Examples

Input: \\\`const x = data.map(d => d.name)\\\`
Output:
[
  {
    "severity": "warning",
    "line": 1,
    "message": "No null check on data before .map()",
    "suggestion": "Use optional chaining: data?.map(d => d.name) ?? []"
  }
]\`;

Step 3: Implement structured output with OpenAI

import OpenAI from "openai";
import { z } from "zod";
import { zodResponseFormat } from "openai/helpers/zod";

const FindingSchema = z.object({
  severity: z.enum(["critical", "warning", "info"]),
  line: z.number(),
  message: z.string(),
  suggestion: z.string(),
});

const ReviewSchema = z.object({
  findings: z.array(FindingSchema),
});

const client = new OpenAI();

async function reviewCode(diff: string) {
  const response = await client.responses.create({
    model: "gpt-4o",
    instructions: systemPrompt,
    input: diff,
    text: {
      format: zodResponseFormat(ReviewSchema, "code_review"),
    },
  });

  return ReviewSchema.parse(JSON.parse(response.output_text));
}

Step 4: Implement with Anthropic

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

async function reviewCodeClaude(diff: string) {
  const response = await client.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: 2048,
    system: systemPrompt,
    messages: [{ role: "user", content: diff }],
  });

  const text = response.content
    .filter(block => block.type === "text")
    .map(block => block.text)
    .join("");

  return JSON.parse(text);
}

Step 5: Add chain-of-thought for complex reasoning

const chainOfThoughtPrompt = \`You are solving a complex problem.

## Process
Think through this step by step:

1. **Understand**: Restate the problem in your own words
2. **Decompose**: Break it into sub-problems
3. **Solve**: Work through each sub-problem
4. **Verify**: Check your solution against the original constraints
5. **Format**: Present the final answer

## Output format
<thinking>
[Your step-by-step reasoning here — be thorough]
</thinking>

<answer>
[Your final, concise answer here]
</answer>\`;

Examples

Example 1: Classification with few-shot

const classificationPrompt = \`Classify the support ticket into exactly one category.

Categories: billing, technical, account, feature-request, other

## Examples

Ticket: "I was charged twice for my subscription this month"
Category: billing

Ticket: "The API returns 500 errors when I send more than 10 requests"
Category: technical

Ticket: "Can you add dark mode to the dashboard?"
Category: feature-request

Ticket: "I can't log in after resetting my password"
Category: account

## Rules
- Return only the category name, nothing else
- If genuinely ambiguous, choose the most actionable category
- "other" is the last resort — use it only when no category fits\`;

Example 2: Data extraction with structured output

const extractionPrompt = \`Extract structured event information from the text.

Return JSON matching this schema exactly:
{
  "event_name": "string",
  "date": "YYYY-MM-DD or null",
  "time": "HH:MM or null",
  "location": "string or null",
  "attendees": ["string"],
  "confidence": 0.0-1.0
}

## Rules
- If a field is not mentioned, use null (not a guess)
- Parse relative dates against today's date provided in the user message
- List only explicitly named attendees, not implied ones
- Confidence reflects how clearly the information was stated\`;

Example 3: Multi-turn agent instructions

const agentSystemPrompt = \`You are a research assistant that helps users
find and synthesize information.

## Available tools
- web_search(query: string) — search the web for information
- read_url(url: string) — read the content of a web page
- save_note(title: string, content: string) — save a research note

## Behavior
1. When the user asks a question, search for relevant sources first
2. Read the top 2-3 results to gather information
3. Synthesize findings into a concise answer with citations
4. Save important findings as notes for future reference

## Citation format
Use inline citations: "The API supports 100 req/s [1]"
List sources at the end:
[1] https://docs.example.com/rate-limits

## Constraints
- Never fabricate information — if you can't find it, say so
- Always cite sources for factual claims
- Prefer official documentation over blog posts
- If search returns no results, suggest alternative queries\`;

Decision tree

What type of prompt do you need?
├── Classification / Routing
│   ├── < 5 categories → Zero-shot with category list
│   └── > 5 categories or subtle distinctions → Few-shot with examples
├── Data extraction
│   ├── Fixed schema → Structured output (JSON mode / zodResponseFormat)
│   └── Variable schema → Describe output format in prompt
├── Reasoning / Analysis
│   ├── Single-step → Zero-shot with clear instructions
│   └── Multi-step → Chain-of-thought with <thinking> blocks
├── Generation / Writing
│   ├── Consistent style → Few-shot with 3+ examples
│   └── Creative → Higher temperature, fewer constraints
└── Agent / Tool use
    ├── Simple tool routing → ReAct pattern in system prompt
    └── Complex orchestration → Agent orchestration skill

Edge cases and gotchas

• Prompt injection: Never put untrusted user input directly in the system prompt — use the user message field
• Token budget: System prompts count against context window — measure and optimize
• Model drift: Prompts that work on GPT-4o may not work on Claude — test across providers
• Few-shot ordering: The last example has the most influence — put your best example last
• Negative instructions: "Don't do X" is weaker than "Always do Y instead of X"
• Output format compliance: Models may drift from the requested format — use structured outputs or regex validation
• Temperature 0 is not deterministic: It's greedy decoding, not true determinism — outputs can still vary slightly
• Long prompts degrade: Performance drops as system prompts exceed ~2000 tokens — distill ruthlessly
• XML tags in Claude: Anthropic models respond well to XML structure: <rules>, <examples>, <output>
• JSON mode quirks: OpenAI's JSON mode requires "JSON" in the prompt; structured outputs (zodResponseFormat) don't

Evaluation criteria

Research-backed changes

The biggest delta is Google AI for Developers. Fold the concrete changes into the operating notes, then discard the fluff.

Fresh signals

• Google AI for Developers · Google AI Dev
• Terms · Google AI Dev
• Privacy · Google AI Dev
• News · Anthropic News

Next edits

• Add one new tactic based on Google AI for Developers.
• Rewrite one stale section with today's source language.
• Turn the top signal into a reusable agent prompt.