소스 정보
- 저장소
- BEKO2210/Firstbrain
- 최근 소스 활동
- 2026년 5월 17일 12:40
- 감지된 SKILL.md 언어
- 영어
- 스타
- 15
- 포크
- 2
설치 방법
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
소스 파일 검토
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
메뉴
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/BEKO2210/Firstbrain --skill ai-wrapper-product명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
SOC 직업 분류 기준
SKILL.md 표시 중
| name | ai-wrapper-product |
| description | Expert in building products that wrap AI APIs (OpenAI, Anthropic, |
| type | skill |
| created | 2026-02-27T00:00:00.000Z |
| domain | business-marketing |
| category | product-management |
| risk | unknown |
| source | vibeship-spawner-skills (Apache 2.0) |
| tags | ["skill","business-marketing","product-management","wrapper","product"] |
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.
Building products around AI APIs
When to use: When designing an AI-powered product
User Input
↓
Input Validation + Sanitization
↓
Prompt Template + Context
↓
AI API (OpenAI/Anthropic/etc.)
↓
Output Parsing + Validation
↓
User-Friendly Response
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');
}
systemPrompt = ;
response = anthropic..({
: ,
: ,
: systemPrompt,
: [{
: ,
: userInput
}]
});
output = response.[].;
(output);
}
| 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 |
Production-grade prompt design
When to use: When building AI product prompts
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`,
},
};
// 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');
}
}
| Technique | Purpose |
|---|---|
| Examples in prompt | Guide output style |
| Output format spec | Consistent structure |
| Validation | Catch malformed responses |
| Retry logic | Handle failures |
| Fallback models | Reliability |
Controlling AI API costs
When to use: When building profitable AI products
// Track usage
async function callWithCostTracking(userId, prompt) {
const response = await anthropic.messages.create({...});
// Log usage
await db.usage.create({
userId,
inputTokens: response.usage.input_tokens,
outputTokens: response.usage.output_tokens,
cost: calculateCost(response.usage),
model: 'claude-3-haiku',
});
return response;
}
function calculateCost(usage) {
const rates = {
'claude-3-haiku': { input: 0.25, output: 1.25 }, // per 1M tokens
};
const rate = rates['claude-3-haiku'];
return (usage.input_tokens * rate.input +
usage.output_tokens * rate.output) / 1_000_000;
}
| Strategy | Savings |
|---|---|
| Use cheaper models | 10-50x |
| Limit output tokens | Variable |
| Cache common queries | High |
| Batch similar requests | Medium |
| Truncate input | Variable |
async function checkUsageLimits(userId) {
const usage = await db.usage.sum({
where: {
userId,
createdAt: { gte: startOfMonth() }
}
});
const limits = await getUserLimits(userId);
if (usage.cost >= limits.monthlyCost) {
throw new Error('Monthly limit reached');
}
return true;
}
Standing out from other AI wrappers
When to use: When planning AI product strategy
| Moat | Example |
|---|---|
| Workflow integration | Email inside Gmail |
| Domain expertise | Legal AI with law training |
| Data/context | Company-specific knowledge |
| UX excellence | Perfectly designed for task |
| Distribution | Built-in audience |
1. Vertical Focus
Generic: "AI writing assistant"
Specific: "AI for Amazon product descriptions"
2. Workflow Integration
Standalone: Web app
Integrated: Chrome extension, Slack bot
3. Domain Training
Generic: Uses raw GPT
Specialized: Fine-tuned or RAG-enhanced
4. Output Quality
Basic: Raw AI output
Polished: Post-processing, formatting, validation
| Thin Wrapper | Real Product |
|---|---|
| ChatGPT with custom prompt | Domain-specific workflow tool |
| API passthrough | Processed, validated outputs |
| Single feature | Complete solution |
| No unique value | Solves specific pain point |
Severity: HIGH
Situation: Monthly AI bill is higher than revenue
Symptoms:
Why this breaks: No usage tracking. No user limits. Using expensive models. Abuse or bugs.
Recommended fix:
// Per-user limits
const LIMITS = {
free: { dailyCalls: 10, monthlyTokens: 50000 },
pro: { dailyCalls: 100, monthlyTokens: 500000 },
};
async function checkLimits(userId) {
const plan = await getUserPlan(userId);
const usage = await getDailyUsage(userId);
if (usage.calls >= LIMITS[plan].dailyCalls) {
throw new Error('Daily limit reached');
}
}
OpenAI: Set usage limits in dashboard
Anthropic: Set spend limits
Add alerts at 50%, 80%, 100%
// Alert on anomalies
async function checkCostAnomaly() {
const todayCost = await getTodayCost();
const avgCost = await getAverageDailyCost(30);
if (todayCost > avgCost * 3) {
await alertAdmin('Cost anomaly detected');
}
}
// Kill switch
const MAX_DAILY_SPEND = 100; // $100
async function canMakeAPICall() {
const todaySpend = await getTodaySpend();
if (todaySpend >= MAX_DAILY_SPEND) {
await disableAPI();
await alertAdmin('Emergency shutoff triggered');
return false;
}
return true;
}
Severity: HIGH
Situation: API calls fail with 429 errors
Symptoms:
Why this breaks: No retry logic. Not queuing requests. Burst traffic not handled. No backoff strategy.
Recommended fix:
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;
}
}
}
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({...}));
}
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;
}
Severity: HIGH
Situation: Users complain about incorrect outputs
Symptoms:
Why this breaks: No output validation. Trusting AI blindly. No fact-checking. Wrong use case for AI.
Recommended fix:
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;
}
// 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
// ...
}
| 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 |
Severity: MEDIUM
Situation: Users complain about slow responses
Symptoms:
Why this breaks: Large prompts. Expensive models. No streaming. No caching.
Recommended fix:
// 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));
}
async function generateWithCache(prompt) {
const cacheKey = hashPrompt(prompt);
const cached = await cache.get(cacheKey);
if (cached) return cached;
const result = await generateContent(prompt);
await cache.set(cacheKey, result, { ttl: 3600 });
return result;
}
| Model | Typical Latency |
|---|---|
| GPT-4 | 5-15s |
| GPT-4o-mini | 1-3s |
| Claude 3 Haiku | 1-3s |
| Claude 3.5 Sonnet | 2-5s |
Severity: HIGH
Message: AI API key may be exposed - security risk!
Fix action: Move API calls to backend, use environment variables
Severity: HIGH
Message: Not tracking AI usage - cost control issue.
Fix action: Log tokens and costs for every API call
Severity: HIGH
Message: AI errors not handled gracefully.
Fix action: Add try/catch, retry logic, and user-friendly error messages
Severity: MEDIUM
Message: Not validating AI outputs.
Fix action: Add output parsing, validation, and error handling
Severity: LOW
Message: Not using streaming - could improve UX.
Fix action: Implement streaming for better perceived performance
Skills: ai-wrapper-product, frontend, micro-saas-launcher
Workflow:
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
Skills: ai-wrapper-product, browser-extension-builder
Workflow:
1. Define AI-powered feature
2. Build extension structure
3. Integrate AI API via backend
4. Add usage limits
5. Publish to Chrome Store
Skills: ai-wrapper-product, telegram-bot-builder
Workflow:
1. Define bot personality/purpose
2. Build Telegram bot
3. Integrate AI for responses
4. Add monetization
5. Launch and grow
Works well with: llm-architect, micro-saas-launcher, frontend, backend