Prompt Engineering for Developers

import OpenAI from 'openai';

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

async function classifyAndRoute(ticket) {
  const response = await openai.chat.completions.create({
    model: "gpt-4o",
    temperature: 0.1, // Low temp for consistent classification
    response_format: { type: "json_object" },
    messages: [
      {
        role: "system",
        content: `You are a support ticket classifier for a SaaS product.
        
Classify each ticket and return JSON with:
{
  "category": "bug" | "feature" | "question" | "billing" | "urgent",
  "priority": 1-5 (5 = most urgent),
  "team": "engineering" | "product" | "support" | "billing",
  "summary": "one-line summary under 100 characters"
}

Rules:
- Anything mentioning "data loss", "can't login", or "security" is priority 5
- Feature requests are always priority 2 unless from enterprise customers
- When unsure between categories, choose the one that gets faster response`
      },
      {
        role: "user",
        content: `Classify this ticket: "${ticket}"`
      }
    ]
  });

  return JSON.parse(response.choices[0].message.content);
}

// Usage
const result = await classifyAndRoute(
  "I can't export my data and I have a board meeting tomorrow"
);
// { category: "bug", priority: 4, team: "engineering", summary: "Export functionality broken - time-sensitive" }

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

const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });

async function reviewCode(code, language) {
  const response = await anthropic.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: 2048,
    system: `You are a code reviewer. Analyze code for bugs, security issues, and performance problems.

Think through each potential issue step by step before deciding if it's a real problem.
Only flag issues you're confident about — false positives waste developer time.

Use XML tags to structure your response:
<reasoning>Your step-by-step analysis</reasoning>
<issues>
  <issue severity="critical|warning|suggestion">
    <location>line or function name</location>
    <description>what's wrong</description>
    <fix>how to fix it</fix>
  </issue>
</issues>
<summary>One paragraph overall assessment</summary>`,
    messages: [
      { role: "user", content: `Review this ${language} code:\n\n${code}` }
    ]
  });

  return response.content[0].text;
}

// The model reasons through each line, then only reports genuine issues
// Separating <reasoning> from <issues> lets you show/hide the thinking

async function answerFromDocs(question, relevantDocs) {
  const response = await openai.chat.completions.create({
    model: "gpt-4o",
    response_format: { type: "json_object" },
    messages: [
      {
        role: "system",
        content: `Answer developer questions using ONLY the provided documentation.
        
Return JSON: { "answer": "...", "sources": ["doc_id"], "confidence": 0-1 }

If the docs don't contain the answer, set confidence to 0 and answer to 
"I don't have enough information to answer this accurately."

Examples:
Q: "How do I authenticate?" + docs about auth
→ { "answer": "Use Bearer tokens in the Authorization header...", "sources": ["auth-guide"], "confidence": 0.95 }

Q: "What's the pricing?" + docs about API endpoints  
→ { "answer": "I don't have enough information to answer this accurately.", "sources": [], "confidence": 0 }`
      },
      {
        role: "user",
        content: `Documentation:\n${relevantDocs.map(d => `[${d.id}] ${d.content}`).join('\n\n')}\n\nQuestion: ${question}`
      }
    ]
  });
  
  return JSON.parse(response.choices[0].message.content);
}

// Prompt chaining example: code review pipeline
const step1 = await llm("Identify the top 3 bugs in this code: ...");
const step2 = await llm(`For each bug, suggest a fix:\n${step1}`);
const step3 = await llm(`Generate the corrected code:\n${step2}`);
// Each step builds on the previous, producing higher quality than one-shot

// Prompt template pattern
const templates = {
  codeReview: ({ language, code, focus }) => `
Review this ${language} code. Focus on: ${focus}.
Only report issues you're confident about.

\`\`\`${language}
${code}
\`\`\`

Return JSON: [{ "line": number, "severity": "critical"|"warning", "issue": string, "fix": string }]
`,
  summarize: ({ text, maxWords, audience }) => `
Summarize the following for a ${audience} audience in under ${maxWords} words:
${text}
`
};