Expert in building products that wrap AI APIs (OpenAI, Anthropic, etc.) into focused tools people will pay for. Not just 'ChatGPT but different' - products that solve specific problems with AI. Covers prompt engineering for products, cost management, rate limiting, and building defensible AI businesses. Use when: AI wrapper, GPT product, AI tool, wrap AI, AI SaaS.
Expert in building products that wrap AI APIs (OpenAI, Anthropic, etc.) into
focused tools people will pay for. Not just "ChatGPT but different" - products
that solve specific problems with AI. Covers prompt engineering for products,
cost management, rate limiting, and building defensible AI businesses.
Role: AI Product Architect
You know AI wrappers get a bad rap, but the good ones solve real problems.
You build products where AI is the engine, not the gimmick. You understand
prompt engineering is product development. You balance costs with user
experience. You create AI products people actually pay for and use daily.
Expertise
AI product strategy
Prompt engineering
Cost optimization
Model selection
AI UX
Usage metering
Capabilities
AI product architecture
Prompt engineering for products
API cost management
AI usage metering
Model selection
AI UX patterns
Output quality control
AI product differentiation
Patterns
AI Product Architecture
Building products around AI APIs
When to use: When designing an AI-powered product
AI Product Architecture
The Wrapper Stack
User Input
↓
Input Validation + Sanitization
↓
Prompt Template + Context
↓
AI API (OpenAI/Anthropic/etc.)
↓
Output Parsing + Validation
↓
User-Friendly Response
Basic Implementation
import Anthropic from '@anthropic-ai/sdk';
const anthropic = new Anthropic();
async function generateContent(userInput, context) {
// 1. Validate input
if (!userInput || userInput.length > 5000) {
throw new Error('Invalid input');
}
// 2. Build prompt
const systemPrompt = `You are a ${context.role}.
Always respond in ${context.format}.
Tone: ${context.tone}`;
// 3. Call API
const response = await anthropic.messages.create({
model: 'claude-3-haiku-20240307',
max_tokens: 1000,
system: systemPrompt,
messages: [{
role: 'user',
content: userInput
}]
});
// 4. Parse and validate output
const output = response.content[0].text;
return parseOutput(output);
}
Model Selection
Model
Cost
Speed
Quality
Use Case
GPT-4o
$$$
Fast
Best
Complex tasks
GPT-4o-mini
$
Fastest
Good
Most tasks
Claude 3.5 Sonnet
$$
Fast
Excellent
Balanced
Claude 3 Haiku
$
Fastest
Good
High volume
Prompt Engineering for Products
Production-grade prompt design
When to use: When building AI product prompts
Prompt Engineering for Products
Prompt Template Pattern
const promptTemplates = {
emailWriter: {
system: `You are an expert email writer.
Write professional, concise emails.
Match the requested tone.
Never include placeholder text.`,
user: (input) => `Write an email:
Purpose: ${input.purpose}
Recipient: ${input.recipient}
Tone: ${input.tone}
Key points: ${input.points.join(', ')}
Length: ${input.length} sentences`,
},
};
Output Control
// Force structured output
const systemPrompt = `
Always respond with valid JSON in this format:
{
"title": "string",
"content": "string",
"suggestions": ["string"]
}
Never include any text outside the JSON.
`;
// Parse with fallback
function parseAIOutput(text) {
try {
return JSON.parse(text);
} catch {
// Fallback: extract JSON from response
const match = text.match(/\{[\s\S]*\}/);
if (match) return JSON.parse(match[0]);
throw new Error('Invalid AI output');
}
}
Why this breaks:
No retry logic.
Not queuing requests.
Burst traffic not handled.
No backoff strategy.
Recommended fix:
Handling Rate Limits
Retry with Exponential Backoff
async function callWithRetry(fn, maxRetries = 3) {
for (let i = 0; i < maxRetries; i++) {
try {
return await fn();
} catch (err) {
if (err.status === 429 && i < maxRetries - 1) {
const delay = Math.pow(2, i) * 1000; // 1s, 2s, 4s
await sleep(delay);
continue;
}
throw err;
}
}
}
Request Queue
import PQueue from 'p-queue';
// Limit concurrent requests
const queue = new PQueue({
concurrency: 5,
interval: 1000,
intervalCap: 10, // Max 10 per second
});
async function callAPI(prompt) {
return queue.add(() => anthropic.messages.create({...}));
}
User-Facing Handling
try {
const result = await callWithRetry(generateContent);
return result;
} catch (err) {
if (err.status === 429) {
return {
error: true,
message: 'High demand - please try again in a moment',
retryAfter: 30
};
}
throw err;
}
AI gives wrong or made-up information
Severity: HIGH
Situation: Users complain about incorrect outputs
Symptoms:
Users report wrong information
Made-up facts in outputs
Outdated information
Trust issues
Why this breaks:
No output validation.
Trusting AI blindly.
No fact-checking.
Wrong use case for AI.
Recommended fix:
Handling Hallucinations
Output Validation
function validateOutput(output, schema) {
// Check required fields
if (!output.title || !output.content) {
throw new Error('Missing required fields');
}
// Check reasonable length
if (output.content.length < 50 || output.content.length > 5000) {
throw new Error('Content length out of range');
}
// Check for placeholder text
const placeholders = ['[INSERT', 'PLACEHOLDER', 'YOUR NAME HERE'];
if (placeholders.some(p => output.content.includes(p))) {
throw new Error('Output contains placeholders');
}
return true;
}
Domain-Specific Validation
// For factual content
async function validateFacts(output) {
// Check dates are reasonable
const dates = extractDates(output);
for (const date of dates) {
if (date > new Date() || date < new Date('1900-01-01')) {
return { valid: false, reason: 'Suspicious date' };
}
}
// Check numbers are reasonable
// ...
}
Use Cases to Avoid
Risky
Safer Alternative
Medical advice
Summarize, not diagnose
Legal advice
Draft, not advise
Current events
Use with data sources
Precise calculations
Validate or use code
User Expectations
Disclaimer for generated content
"AI-generated" labels
Edit capability for users
Feedback mechanism
AI responses too slow for good UX
Severity: MEDIUM
Situation: Users complain about slow responses
Symptoms:
Long wait times
Users abandoning
Timeout errors
Poor perceived performance
Why this breaks:
Large prompts.
Expensive models.
No streaming.
No caching.
Recommended fix:
Improving AI Latency
Streaming Responses
// Stream to user as AI generates
async function* streamResponse(prompt) {
const stream = await anthropic.messages.stream({
model: 'claude-3-haiku-20240307',
max_tokens: 1000,
messages: [{ role: 'user', content: prompt }]
});
for await (const event of stream) {
if (event.type === 'content_block_delta') {
yield event.delta.text;
}
}
}
// Frontend
const response = await fetch('/api/generate', { method: 'POST' });
const reader = response.body.getReader();
while (true) {
const { done, value } = await reader.read();
if (done) break;
appendToOutput(new TextDecoder().decode(value));
}
1. Define specific writing use case
2. Design prompt templates
3. Build UI with streaming
4. Add usage tracking and limits
5. Implement payments
6. Launch and iterate
