Prompt Engineering Pattern | Bootspring Docs

Craft effective prompts for reliable, high-quality AI outputs with structured responses and consistent behavior.

Overview#

Prompt engineering is the practice of designing inputs to AI models that produce desired outputs reliably. Well-crafted prompts reduce errors, improve consistency, and enable complex behaviors.

When to use:

Any AI-powered feature
Structured data extraction
Content generation
Classification tasks
Complex reasoning tasks

Key features:

System prompt design
Output format specification
Few-shot examples
Chain-of-thought reasoning
Structured output with schemas

Code Example#

System Prompt Design#

// lib/ai/prompts.ts
export const systemPrompts = {
  // Clear role and constraints
  assistant: `You are a helpful customer support assistant for Acme Inc.
Your role is to help customers with product questions and issues.

Guidelines:
- Be friendly and professional
- Only discuss Acme products and services
- If you don't know something, say so
- Never make up product features or prices
- Suggest contacting support for complex issues`,

  // Technical assistant with specific format
  codeReviewer: `You are an expert code reviewer.
Review code for:
- Bugs and potential errors
- Security vulnerabilities
- Performance issues
- Code style and readability

Format your response as:
## Summary
Brief overview of the code quality

## Issues Found
List each issue with severity (Critical/Warning/Info)

## Suggestions
Specific improvements with code examples`,

  // Data extraction with schema
  entityExtractor: `You are a data extraction system.
Extract structured information from text.
Always return valid JSON matching the requested schema.
If information is not present, use null.
Never add fields not in the schema.`
}

Structured Output with Zod#

// lib/ai/structured.ts
import { anthropic } from '@/lib/anthropic'
import { z } from 'zod'

const ProductSchema = z.object({
  name: z.string(),
  description: z.string(),
  price: z.number(),
  category: z.string()
})

export async function extractProduct(text: string) {
  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 1024,
    system: `Extract product information and return as JSON.
Return only the JSON object, no other text.`,
    messages: [
      {
        role: 'user',
        content: `Extract product information from this text:

${text}

Return JSON with: name, description, price (number), category`
      }
    ]
  })

  const content = response.content[0]
  if (content.type !== 'text') throw new Error('Unexpected response')

  const jsonMatch = content.text.match(/\{[\s\S]*\}/)
  if (!jsonMatch) throw new Error('No JSON found')

  const parsed = JSON.parse(jsonMatch[0])
  return ProductSchema.parse(parsed)
}

Few-Shot Examples#

// lib/ai/classification.ts
import { anthropic } from '@/lib/anthropic'

const CATEGORIES = ['bug', 'feature', 'question', 'docs'] as const

export async function classifyIssue(
  title: string,
  body: string
): Promise<typeof CATEGORIES[number]> {
  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 50,
    messages: [
      {
        role: 'user',
        content: `Classify GitHub issues. Categories: bug, feature, question, docs

Examples:
Title: "App crashes on login"
Body: "When I try to log in, the app crashes"
Category: bug

Title: "Add dark mode support"
Body: "It would be great to have a dark theme option"
Category: feature

Title: "How do I reset my password?"
Body: "I forgot my password and can't find reset option"
Category: question

Title: "Fix typo in README"
Body: "Line 42 says 'teh' instead of 'the'"
Category: docs

Now classify:
Title: "${title}"
Body: "${body}"
Category:`
      }
    ]
  })

  const text = response.content[0].type === 'text'
    ? response.content[0].text.trim().toLowerCase()
    : ''

  if (CATEGORIES.includes(text as any)) {
    return text as typeof CATEGORIES[number]
  }

  return 'question' // default
}

Chain-of-Thought Reasoning#

// lib/ai/reasoning.ts
import { anthropic } from '@/lib/anthropic'

export async function analyzeWithReasoning(problem: string) {
  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 2048,
    system: `You are an analytical assistant.
When solving problems, think step by step:
1. First, understand what is being asked
2. Break down the problem into parts
3. Analyze each part
4. Synthesize your findings
5. Provide a clear conclusion

Format:
## Understanding
What the problem is asking

## Analysis
Step-by-step reasoning

## Conclusion
Final answer with confidence level`,
    messages: [
      { role: 'user', content: problem }
    ]
  })

  return response.content[0].type === 'text'
    ? response.content[0].text
    : null
}

Entity Extraction#

// lib/ai/extract.ts
import { anthropic } from '@/lib/anthropic'
import { z } from 'zod'

const EntitiesSchema = z.object({
  people: z.array(z.string()),
  organizations: z.array(z.string()),
  locations: z.array(z.string()),
  dates: z.array(z.string())
})

export async function extractEntities(text: string) {
  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 1024,
    system: `Extract named entities from text.
Return a JSON object with arrays for: people, organizations, locations, dates.
Use empty arrays if no entities found for a category.`,
    messages: [
      {
        role: 'user',
        content: `Extract named entities from:

${text}

Return only the JSON object.`
      }
    ]
  })

  const content = response.content[0]
  if (content.type !== 'text') throw new Error('Unexpected response')

  const jsonMatch = content.text.match(/\{[\s\S]*\}/)
  if (!jsonMatch) throw new Error('No JSON found')

  return EntitiesSchema.parse(JSON.parse(jsonMatch[0]))
}

Conversation Context Management#

// lib/ai/conversation.ts
import { anthropic } from '@/lib/anthropic'

interface Message {
  role: 'user' | 'assistant'
  content: string
}

export async function chat(
  messages: Message[],
  systemPrompt: string
) {
  // Keep conversation within token limits
  const recentMessages = messages.slice(-10)

  // Add context summary for long conversations
  let contextSummary = ''
  if (messages.length > 10) {
    contextSummary = `Previous conversation summary: ${await summarizeConversation(messages.slice(0, -10))}\n\n`
  }

  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 1024,
    system: systemPrompt + (contextSummary ? `\n\n${contextSummary}` : ''),
    messages: recentMessages
  })

  return response.content[0].type === 'text'
    ? response.content[0].text
    : null
}

async function summarizeConversation(messages: Message[]): Promise<string> {
  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 200,
    messages: [
      {
        role: 'user',
        content: `Summarize this conversation in 2-3 sentences:

${messages.map(m => `${m.role}: ${m.content}`).join('\n')}`
      }
    ]
  })

  return response.content[0].type === 'text'
    ? response.content[0].text
    : ''
}

Usage Instructions#

Define clear roles - Start system prompts with the AI's role and purpose
Set constraints - Explicitly state what the AI should and shouldn't do
Specify output format - Tell the AI exactly how to structure responses
Use examples - Provide few-shot examples for complex tasks
Validate outputs - Parse and validate structured responses with Zod

Best Practices#

Be specific - Vague prompts produce vague results
Show, don't just tell - Include examples of desired outputs
Separate concerns - Use system prompt for behavior, user message for task
Handle edge cases - Tell the AI what to do when uncertain
Iterate and test - Refine prompts based on real outputs
Version your prompts - Track changes to important prompts
Use structured output - Request JSON for data extraction
Set constraints early - Put important rules at the beginning

Claude API - Basic Claude integration
Function Calling - Tool use patterns
Streaming - Real-time responses