Product Expert Design
Guide for designing agent experts that serve end users through adaptive, personalized experiences.
Codebase Experts vs Product Experts
| Aspect | Codebase Expert | Product Expert | | --- | --- | --- | | Scope | One per domain | One per user | | Storage | File system (YAML) | Database (JSONB) | | Updates | After code changes | After user actions | | Size | 300-1000 lines | Typically smaller | | Latency | Not critical | Must be fast | | Privacy | Internal only | User data concerns |
When to Use
- Building product features that learn from user behavior
- Creating per-user expertise files for personalization
- Implementing AI-driven adaptive UX
- Designing recommendation systems with user mental models
- Evaluating whether product experts are appropriate for your use case
- Building progressive personalization with latency considerations
Product Expert Architecture
┌─────────────────────────────────────────────────────┐
│ User Action (view, click, purchase, etc.) │
└──────────────────────┬──────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────┐
│ Action Tracker │
│ • Capture action type │
│ • Record context (time, device, etc.) │
│ • Queue for expertise update │
└──────────────────────┬──────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────┐
│ User Expertise Store (Database) │
│ • Per-user JSONB column │
│ • Structured preference model │
│ • Behavior patterns │
└──────────────────────┬──────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────┐
│ UI Generation Agent │
│ • Load user expertise │
│ • Generate personalized UI │
│ • Adapt recommendations │
└─────────────────────────────────────────────────────┘
User Expertise Schema
{
"user_id": "uuid",
"created_at": "timestamp",
"updated_at": "timestamp",
"preferences": {
"categories": ["tech", "sports"],
"price_range": {"min": 50, "max": 500},
"brands": ["Apple", "Sony"],
"style": "minimalist"
},
"behavior_patterns": {
"active_hours": [9, 10, 11, 14, 15, 20, 21],
"device_preference": "mobile",
"session_length_avg": 420,
"purchase_frequency": "monthly"
},
"interaction_history": {
"views": [
{"item_id": "123", "timestamp": "...", "duration": 45}
],
"cart_adds": [
{"item_id": "456", "timestamp": "..."}
],
"purchases": [
{"item_id": "789", "timestamp": "...", "amount": 299}
]
},
"inferred_interests": {
"high": ["wireless headphones", "smart home"],
"medium": ["fitness trackers"],
"low": ["gaming"]
},
"recommendations_context": {
"last_shown": ["item1", "item2"],
"clicked": ["item1"],
"dismissed": ["item3"]
}
}
Act-Learn-Reuse for Products
ACT: User Takes Action
async function trackUserAction(
userId: string,
action: UserAction
): Promise<void> {
// Record the action
await db.userActions.create({
userId,
actionType: action.type,
context: action.context,
timestamp: new Date()
});
// Queue expertise update
await expertiseQueue.add({
userId,
action,
priority: getActionPriority(action.type)
});
}
LEARN: Update User Expertise
async function updateUserExpertise(
userId: string,
action: UserAction
): Promise<void> {
// Load current expertise
const expertise = await loadUserExpertise(userId);
// Update based on action type
switch (action.type) {
case 'view':
updateViewPatterns(expertise, action);
break;
case 'cart_add':
updatePurchaseIntent(expertise, action);
break;
case 'purchase':
updatePreferences(expertise, action);
break;
}
// Recalculate inferred interests
expertise.inferred_interests = inferInterests(expertise);
// Save updated expertise
await saveUserExpertise(userId, expertise);
}
REUSE: Personalized Experience
async function generatePersonalizedUI(
userId: string
): Promise<UIConfig> {
// Load user expertise first
const expertise = await loadUserExpertise(userId);
// Generate UI based on expertise
return {
recommendations: await getRecommendations(expertise),
layout: selectLayout(expertise.behavior_patterns),
promotions: filterPromotions(expertise.preferences),
navigation: prioritizeCategories(expertise.inferred_interests)
};
}
Latency Considerations
Product experts face latency challenges that codebase experts don't:
The Problem
User Request → Load Expertise → Generate UI → Response
↓
Agent thinking time (seconds)
↓
User waiting... (bad UX)
Solutions
1. Pre-computation
// Update expertise async, not on-demand
// Pre-generate UI components during low traffic
2. Progressive Loading
// Show generic UI immediately
// Load personalized elements async
// Swap in when ready
3. Expertise Caching
// Cache hot user expertise in Redis
// Invalidate on significant changes only
4. Tiered Personalization
// Level 1: Instant (cached preferences)
// Level 2: Fast (simple inference)
// Level 3: Deep (full agent, async)
Privacy and Data Handling
Data Minimization
Only store what you need:
// Good: Store patterns, not raw data
{
"preferred_price_range": {"min": 100, "max": 300},
"category_affinity": {"tech": 0.8, "fashion": 0.3}
}
// Bad: Store every view with full context
{
"views": [/* hundreds of detailed entries */]
}
User Control
Provide transparency and control:
interface UserExpertiseControls {
viewExpertise(): UserExpertise;
clearExpertise(): void;
disablePersonalization(): void;
exportData(): DataExport;
}
Retention Policies
// Decay old data
function decayOldInteractions(expertise: UserExpertise): void {
const cutoff = daysAgo(90);
expertise.interaction_history =
expertise.interaction_history.filter(i => i.timestamp > cutoff);
}
When to Use Product Experts
| Use Case | Good Fit? | Notes | | --- | --- | --- | | E-commerce recommendations | Yes | High value, clear signals | | Content personalization | Yes | Engagement improves | | Search ranking | Yes | User-specific relevance | | Simple preferences | No | Traditional settings work | | Compliance-heavy domains | Maybe | Privacy concerns | | Low-traffic products | No | Not enough data |
Implementation Checklist
Database Setup
- [ ] User expertise JSONB column
- [ ] Action tracking table
- [ ] Index on user_id for expertise lookup
Backend Services
- [ ] Action tracking endpoint
- [ ] Expertise update worker (async)
- [ ] Expertise query API
- [ ] Cache layer (Redis)
Agent Integration
- [ ] Expertise loading prompt
- [ ] UI generation prompt
- [ ] Recommendation prompt
Frontend
- [ ] Progressive loading UI
- [ ] Skeleton states while personalizing
- [ ] Fallback to generic experience
Privacy
- [ ] Data retention policy
- [ ] User control dashboard
- [ ] Export/delete functionality
Anti-Patterns
| Anti-Pattern | Problem | Solution | | --- | --- | --- | | Sync updates | Blocks user | Async queue | | Unbounded history | DB bloat | Rolling window | | No fallback | Broken for new users | Default experience | | Over-personalization | Filter bubble | Inject diversity | | No decay | Stale preferences | Time-weighted data |
Example: E-commerce Product Expert
## User Expertise Structure
preferences:
price_sensitivity: high|medium|low
brand_loyalty: [list of preferred brands]
category_interests: {category: affinity_score}
behavior:
browse_vs_buy_ratio: 0.15
cart_abandonment_rate: 0.4
avg_time_to_purchase: 3 days
purchase_history:
total_orders: 12
avg_order_value: 150
last_purchase: 2025-01-10
## Personalization Actions
1. Show price-sensitive users sale items first
2. Highlight preferred brands in search results
3. Remind high-abandonment users of cart items
4. Suggest reorder for repeat purchases
Related Skills
agent-expert-creation: Core expert patternsexpertise-file-design: Schema design principlesself-improve-prompt-design: Maintaining accuracy
Last Updated: 2025-12-15
Version History
- v1.0.0 (2025-12-26): Initial release