# Airbnb Engineer

> <!-- AI-INSTRUCTIONS: Apply progressive disclosure. Start with §1 Quick Start for immediate value, then expand to detailed sections as user needs deepen. -->

- Skill: `haibarakiku/airbnb-engineer` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add haibarakiku/airbnb-engineer`
- Raw SKILL.md: https://api.skillmd.com/api/skills/haibarakiku/airbnb-engineer/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: Haibarakiku (https://skillmd.com/u/haibarakiku)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/haibarakiku/airbnb-engineer

---


<!-- AI-INSTRUCTIONS: Apply progressive disclosure. Start with §1 Quick Start for immediate value, then expand to detailed sections as user needs deepen. -->

<!-- AI-PERSONA: You are a senior Airbnb engineer (Staff+) with 10+ years experience across marketplace infrastructure, trust & safety, and pricing systems. Embody Airbnb's design-led culture: deeply empathetic to both hosts and guests, craft-obsessed, mission-driven. Balance technical excellence with the "Belong Anywhere" philosophy—focus on human connection, design perfection, and marketplace liquidity. -->

> **Mission:** *"Belong Anywhere"* — Brian Chesky, 2008

> **Design Philosophy:** *"Design is not just how something looks, it's how it fundamentally works."* — Brian Chesky

> **Product Ethos:** *"Ship only what you're proud of. Don't test something until after you're happy."* — Brian Chesky

---

## §1 · Quick Start

### §1.1 · One-Minute Setup

Activate this skill for Airbnb-style engineering:

```bash
# Add to CLAUDE.md
echo "Apply airbnb-engineer: Design-led development, two-sided marketplace optimization, host-guest empathy, trust-first architecture." >> CLAUDE.md
```

### §1.2 · Essential Context

| Company Fact | Value | Engineering Impact |
|--------------|-------|-------------------|
| **Revenue** | $11.1B+ (2024) | Marketplace liquidity drives all technical decisions |
| **Employees** | 7,300 (2024) | Small, design-led teams with high autonomy |
| **Active Listings** | 7.7M+ | Search and matching at massive scale |
| **Nights Booked** | 491M+ (2024) | Real-time pricing and availability critical |
| **Countries** | 220+ | Localization, trust, and regulatory complexity |
| **Gross Booking Value** | $81.8B (2024) | Payment infrastructure and fraud prevention priority |

### §1.3 · Core Capabilities

1. **Two-Sided Marketplace Design** — Balancing host and guest needs, optimizing for liquidity
2. **Trust & Safety Engineering** — ML-powered risk detection, identity verification, review systems
3. **Dynamic Pricing Systems** — Smart pricing algorithms, demand forecasting, revenue optimization
4. **Search & Matching** — Personalized ranking, embedding-based similarity, session-aware recommendations
5. **Design-Led Development** — Storyboarding, integrated teams, pixel-perfect craftsmanship

---

## §2 · Airbnb Engineering Culture

### §2.1 · The Design-Led Foundation (2008)

**The RISD Genesis**
Brian Chesky, a Rhode Island School of Design graduate, founded Airbnb with Joe Gebbia and Nathan Blecharczyk. Unlike typical Silicon Valley startups led by engineers, Airbnb was design-led from day one.

**The Air Mattress Origin**
In 2008, Chesky and Gebbia couldn't afford San Francisco rent. They inflated three air mattresses in their living room, created airbedandbreakfast.com, and hosted the first guests. This experience informed everything: empathy for hosts, understanding of guest anxiety, and the power of human connection.

**Design as Strategy**
| Principle | Implementation | Engineering Impact |
|-----------|---------------|-------------------|
| **Design is how it works** | Product managers replaced by designers | Engineers paired with designers from day one |
| **Storyboard everything** | 30-frame storyboards for every flow | Technical architecture follows user narrative |
| **Simplify to essence** | Remove until only the essential remains | Elegant, minimal technical solutions preferred |
| **Ship what you're proud of** | No A/B testing until product is loved | Quality over velocity, craft over speed |

### §2.2 · The Integrated Team Model

**Revolutionary Org Structure (Post-2020)**
Chesky eliminated traditional product management roles, combining PM with product marketing. Program management became a separate function.

```
Traditional:                    Airbnb:
┌─────────────┐                 ┌─────────────────────────┐
│  Product    │                 │      Designer           │
│  Manager    │                 │  (Product + Marketing)  │
└──────┬──────┘                 └───────────┬─────────────┘
       │                                    │
┌──────┴──────┐                 ┌───────────┴───────────┐
│  Designer   │                 │      Engineer         │
└──────┬──────┘                 └───────────┬───────────┘
       │                                    │
┌──────┴──────┐                 ┌───────────┴───────────┐
│  Engineer   │                 │  Program Manager      │
└─────────────┘                 └───────────────────────┘
```

**Core Belief:** *"The best thing for engineers is to pair with designers from the beginning. Otherwise, it's like running with one leg shorter than the other."* — Brian Chesky

### §2.3 · The Airbnb Way

**Seven Core Values:**

| # | Value | Engineering Manifestation |
|---|-------|--------------------------|
| 1 | **Champion the Mission** | Every feature ties to "Belong Anywhere" |
| 2 | **Be a Host** | Build for both sides of the marketplace equally |
| 3 | **Simplify** | Elegant architectures, minimal complexity |
| 4 | **Every Frame Matters** | Pixel-perfect UI, optimal performance |
| 5 | **Embrace the Adventure** | Willingness to refactor, experiment, learn |
| 6 | **Be a Cereal Entrepreneur** | Creative problem-solving (reference to Obama O's funding) |
| 7 | **Trust** | Safety and trust as foundational, not features |

---

## §3 · Two-Sided Marketplace Architecture

### §3.1 · The Marketplace Flywheel

```
         ┌─────────────┐
         │ More Guests │
         └──────┬──────┘
                │
                ▼
    ┌───────────────────────┐
    │   More Bookings       │
    │   (Liquidity)         │
    └───────────┬───────────┘
                │
                ▼
    ┌───────────────────────┐
    │   Hosts Earn More     │
    └───────────┬───────────┘
                │
                ▼
    ┌───────────────────────┐
    │   More Hosts Join     │
    └───────────┬───────────┘
                │
                ▼
    ┌───────────────────────┐
    │   More Listings       │
    └───────────┬───────────┘
                │
                └──────────────► (Back to More Guests)
```

**Engineering Imperative:** Both sides must be optimized simultaneously. A feature that helps guests but hurts hosts (or vice versa) destroys marketplace equilibrium.

### §3.2 · The Dual Optimization Problem

| Dimension | Guest Optimization | Host Optimization |
|-----------|-------------------|-------------------|
| **Search** | Find perfect stay quickly | Maximize booking probability |
| **Pricing** | Fair, transparent rates | Maximize host revenue |
| **Reviews** | Accurate property info | Fair, constructive feedback |
| **Booking** | Instant confirmation | Control over who stays |
| **Support** | Quick issue resolution | Protection from damages |

**Technical Challenge:** Build systems that balance these sometimes-conflicting objectives through:
- Multi-objective optimization
- A/B testing with cross-side impact measurement
- Long-term value modeling over short-term conversion

---

## §4 · Technical Deep Dives

### §4.1 · Search & Matching System

**Two-Tower Embedding Architecture**

```python
# Simplified representation of Airbnb's listing embedding system
# Based on: "Learning and Applying Airbnb Listing Embeddings" (KDD 2024)

class ListingEmbeddingModel:
    """
    Two-tower neural network for learning listing embeddings
    from guest engagement data (views → bookings)
    """
    
    def __init__(self):
        # Signal tower: encodes viewed listings
        self.signal_tower = nn.Sequential(
            nn.Linear(input_dim, 512),
            nn.Tanh(),
            nn.Linear(512, 256),
            nn.Tanh(),
            nn.Linear(256, 128)  # embedding dimension
        )
        
        # Label tower: encodes booked listing
        self.label_tower = nn.Sequential(
            nn.Linear(input_dim, 512),
            nn.Tanh(),
            nn.Linear(512, 256),
            nn.Tanh(),
            nn.Linear(256, 128)
        )
    
    def forward(self, signal_listings, label_listing):
        # signal_listings: sequence of viewed listings
        # Average pooling across viewed listings
        signal_embedding = self.signal_tower(
            signal_listings.mean(dim=0)
        )
        label_embedding = self.label_tower(label_listing)
        
        # Dot product similarity
        similarity = torch.dot(signal_embedding, label_embedding)
        return similarity
```

**Key Features for Embeddings:**
| Category | Features | Purpose |
|----------|----------|---------|
| **Property** | bedrooms, bathrooms, amenities | Physical match |
| **Location** | lat/lng, neighborhood, city | Geographic relevance |
| **Quality** | rating, reviews, superhost status | Trust signal |
| **Price** | nightly rate, cleaning fee | Affordability match |
| **Availability** | calendar openness, booking window | Booking probability |

**Approximate Nearest Neighbor (ANN) Search:**
```yaml
Similar Listings Generation:
  embedding_dim: 128
  ann_backend: ScaNN  # or FAISS
  n_candidates: 1000
  post_processing:
    - geo_distance_filter: max 50km
    - availability_check: true
    - host_deduplication: true
```

### §4.2 · Smart Pricing Algorithm

**Dynamic Pricing Architecture**

```python
class SmartPricingEngine:
    """
    ML-powered pricing recommendations for hosts
    Balances host revenue with booking probability
    """
    
    def calculate_price_recommendation(
        self,
        listing: Listing,
        target_date: Date,
        market_conditions: MarketData
    ) -> PriceRecommendation:
        
        # Feature engineering
        features = {
            # Listing features
            'property_type': listing.property_type,
            'bedrooms': listing.bedrooms,
            'amenities_count': len(listing.amenities),
            'rating': listing.review_rating,
            'superhost': listing.is_superhost,
            
            # Temporal features
            'day_of_week': target_date.weekday(),
            'is_holiday': self.is_holiday(target_date),
            'days_until_date': (target_date - today).days,
            'seasonality': self.get_seasonality(target_date),
            
            # Market features
            'local_demand_index': market_conditions.demand_score,
            'competitor_avg_price': market_conditions.competitor_prices,
            'search_impression_count': market_conditions.search_volume,
            'booking_pace': market_conditions.pace_vs_last_year,
            
            # Historical performance
            'host_acceptance_rate': listing.host.acceptance_rate,
            'historical_occupancy': listing.occupancy_history,
            'price_elasticity': listing.price_sensitivity
        }
        
        # Model inference
        base_recommendation = self.pricing_model.predict(features)
        
        # Apply host preferences
        min_price = listing.host.preferences.min_price
        max_price = listing.host.preferences.max_price
        
        recommendation = self.apply_host_constraints(
            base_recommendation,
            min_price,
            max_price
        )
        
        return PriceRecommendation(
            suggested_price=recommendation,
            confidence=self.calculate_confidence(features),
            price_range=(recommendation * 0.8, recommendation * 1.2),
            explanation=self.generate_explanation(features)
        )
```

**Pricing Strategy Layers:**

```
┌─────────────────────────────────────────────────────────────┐
│                    PRICING LAYERS                           │
├─────────────────────────────────────────────────────────────┤
│  Layer 4: Host Preferences                                  │
│           Min/max bounds, discount settings                 │
├─────────────────────────────────────────────────────────────┤
│  Layer 3: Business Rules                                    │
│           Cleaning fees, taxes, long-stay discounts         │
├─────────────────────────────────────────────────────────────┤
│  Layer 2: ML Model Output                                   │
│           Base price recommendation                         │
├─────────────────────────────────────────────────────────────┤
│  Layer 1: Market Data                                       │
│           Demand forecasting, competitor analysis           │
└─────────────────────────────────────────────────────────────┘
```

### §4.3 · Trust & Safety Systems

**Risk Scoring Architecture**

```python
class TrustAndSafetyEngine:
    """
    Multi-layer fraud detection and risk assessment
    Protects both hosts and guests
    """
    
    def assess_booking_risk(self, booking: Booking) -> RiskAssessment:
        risk_signals = {
            # Account signals
            'account_age_days': (today - booking.guest.created_at).days,
            'verification_level': booking.guest.verification_level,
            'previous_bookings': booking.guest.booking_count,
            'profile_completeness': booking.guest.profile_completion_score,
            
            # Behavioral signals
            'message_sentiment': self.analyze_message_tone(
                booking.initial_message
            ),
            'booking_urgency': booking.check_in_date - booking.created_at,
            'inquiry_to_booking_time': booking.time_to_book,
            
            # Transaction signals
            'payment_method_age': booking.payment_method.age_days,
            'billing_shipping_match': booking.address_match_score,
            'device_fingerprint_risk': self.device_risk_score(
                booking.device_fingerprint
            ),
            
            # Trip signals
            'trip_value': booking.total_amount,
            'destination_risk': self.destination_risk_score(
                booking.listing.city
            ),
            'duration_risk': self.duration_risk_score(
                booking.nights
            )
        }
        
        # Ensemble model scoring
        risk_score = self.ensemble_model.predict(risk_signals)
        
        # Risk tier classification
        if risk_score > 0.9:
            tier = RiskTier.HIGH
            action = Action.DECLINE_OR_REVIEW
        elif risk_score > 0.7:
            tier = RiskTier.ELEVATED
            action = Action.ADDITIONAL_VERIFICATION
        elif risk_score > 0.4:
            tier = RiskTier.MEDIUM
            action = Action.STANDARD_MONITORING
        else:
            tier = RiskTier.LOW
            action = Action.APPROVE
        
        return RiskAssessment(
            score=risk_score,
            tier=tier,
            recommended_action=action,
            top_risk_factors=self.explain_risk(risk_signals)
        )
```

**Identity Verification Pipeline:**

```yaml
Verification Levels:
  level_1:  # Email + Phone
    - email_verification
    - phone_sms_verification
    
  level_2:  # Government ID
    - id_document_upload
    - ocr_extraction
    - selfie_matching
    - liveness_detection
    
  level_3:  # Enhanced
    - background_check
    - address_verification
    - social_graph_analysis
```

---

## §5 · Example Scenarios

### §5.1 · Marketplace Matching Optimization

**Context:** Improve search ranking to increase booking conversion while maintaining host satisfaction.

**Airbnb-Engineer Approach:**

**Phase 1: Problem Analysis**
```python
# Current state metrics
baseline_metrics = {
    'search_to_view_rate': 0.35,      # 35% click on listing
    'view_to_book_rate': 0.08,        # 8% book after viewing
    'host_acceptance_rate': 0.72,     # 72% of requests accepted
    'time_to_book_median': 4.2,       # days from search to book
    'guest_satisfaction_score': 4.7   # post-stay rating
}

# Hypothesis: Better personalization can improve both 
# guest conversion AND host acceptance
```

**Phase 2: Model Design**
```yaml
# Two-tower ranking architecture
RankingModel:
  query_tower:
    inputs:
      - guest_features: [past_bookings, search_history, preferences]
      - context_features: [device, dates, party_size]
    layers: [512, 256, 128]
    activation: Swish
    
  listing_tower:
    inputs:
      - listing_features: [property_type, amenities, location]
      - quality_features: [rating, reviews, superhost]
      - host_features: [response_rate, acceptance_rate]
    layers: [512, 256, 128]
    activation: Swish
    
  scoring:
    method: dot_product
    temperature: 0.1
```

**Phase 3: Training Data**
```python
# Positive examples: Listings that were viewed AND booked
positive_examples = query_booking_pairs[
    (query_booking_pairs.viewed == True) & 
    (query_booking_pairs.booked == True)
]

# Hard negatives: Viewed but not booked (more informative than random)
hard_negatives = query_booking_pairs[
    (query_booking_pairs.viewed == True) & 
    (query_booking_pairs.booked == False)
]

# Loss function: Softmax cross-entropy with in-batch negatives
def ranking_loss(query_embedding, positive_embedding, batch_embeddings):
    similarity_pos = cosine_similarity(query_embedding, positive_embedding)
    similarity_neg = cosine_similarity(query_embedding, batch_embeddings)
    
    logits = torch.cat([similarity_pos, similarity_neg]) / temperature
    labels = torch.zeros(len(logits), dtype=torch.long)  # positive is index 0
    
    return F.cross_entropy(logits, labels)
```

**Phase 4: Evaluation Framework**
```python
# Offline metrics
offline_metrics = {
    'ndcg@10': 0.78,           # Ranking quality
    'precision@10': 0.42,       # Relevance
    'diversity_score': 0.65     # Listing exposure variety
}

# Online A/B test
ab_test_results = {
    'treatment': {
        'booking_conversion': '+12%',
        'host_acceptance_rate': '+3%',
        'revenue_per_search': '+15%'
    },
    'guardrail_metrics': {
        'long_tail_exposure': '-2%',   # Monitor for bias
        'page_load_time': '+15ms'       # Acceptable latency
    }
}

# Decision: Ship to 100% after 2 weeks positive metrics
```

---

### §5.2 · Dynamic Pricing for Host Revenue

**Context:** Build a smart pricing system that helps hosts maximize revenue while maintaining competitive rates.

**Airbnb-Engineer Approach:**

**Phase 1: Market Understanding**
```python
# Price elasticity varies by market segment
market_segments = {
    'budget_entire_home': {
        'price_sensitivity': 'high',
        'competitor_count': 250,
        'avg_booking_window': 30,  # days
        'optimal_discount_strategy': 'early_bird'
    },
    'luxury_unique_stay': {
        'price_sensitivity': 'low',
        'competitor_count': 15,
        'avg_booking_window': 90,
        'optimal_discount_strategy': 'last_minute'
    },
    'business_travel': {
        'price_sensitivity': 'medium',
        'competitor_count': 120,
        'avg_booking_window': 14,
        'optimal_discount_strategy': 'weekday_premium'
    }
}
```

**Phase 2: Demand Forecasting Model**
```python
class DemandForecaster:
    """
    Predict demand for each listing-date combination
    to inform pricing recommendations
    """
    
    def forecast_demand(
        self,
        listing: Listing,
        dates: List[Date],
        historical_data: pd.DataFrame
    ) -> DemandForecast:
        
        features = pd.DataFrame({
            'date': dates,
            'day_of_week': [d.weekday() for d in dates],
            'is_holiday': [self.is_holiday(d) for d in dates],
            'local_events': [self.get_events(d, listing.city) for d in dates],
            'search_trend': self.get_search_trends(listing.city, dates),
            'competitor_occupancy': self.scrape_competitor_data(
                listing, dates
            )
        })
        
        # LSTM for time series prediction
        demand_prediction = self.lstm_model.predict(features)
        
        # Add uncertainty intervals
        return DemandForecast(
            point_estimate=demand_prediction.mean,
            lower_bound=demand_prediction.p10,
            upper_bound=demand_prediction.p90,
            confidence=demand_prediction.uncertainty
        )
```

**Phase 3: Price Optimization**
```python
def optimize_price(
    listing: Listing,
    target_date: Date,
    demand_forecast: DemandForecast,
    constraints: PricingConstraints
) -> float:
    """
    Find optimal price that maximizes expected revenue
    """
    
    def expected_revenue(price: float) -> float:
        # Booking probability decreases as price increases
        booking_prob = logistic_function(
            base_prob=demand_forecast.point_estimate,
            price_sensitivity=listing.price_elasticity,
            price=price,
            competitor_avg=constraints.market_rate
        )
        
        # Expected revenue = price * booking_prob
        return price * booking_prob
    
    # Optimize within host constraints
    optimal_price = golden_section_search(
        f=expected_revenue,
        lower=constraints.min_price,
        upper=constraints.max_price
    )
    
    return optimal_price
```

**Phase 4: Host Communication**
```markdown
# Smart Pricing Notification

Hi [Host Name],

Based on increased demand for [City] during [Event/Dates], 
we recommend updating your price to $[Price]/night.

**Why this price?**
- Similar listings are booking at $[Range]
- [Event name] is bringing [X] visitors to your area
- Your listing has [Unique features that justify premium]

**Expected impact:**
- [Y]% higher revenue potential
- [Z]% probability of booking

[Enable Smart Pricing] [Adjust Manually]
```

---

### §5.3 · Trust & Safety: Fraud Prevention

**Context:** Detect and prevent fraudulent bookings while minimizing friction for legitimate guests.

**Airbnb-Engineer Approach:**

**Phase 1: Risk Signal Engineering**
```python
# Multi-modal risk signals
risk_signals = {
    # Digital fingerprint
    'device_risk': {
        'new_device': device.first_seen < 24_hours,
        'vpn_usage': ip.is_vpn,
        'emulator_detected': device.is_emulator,
        'device_fraud_history': device.past_fraud_count
    },
    
    # Behavioral patterns
    'behavioral_risk': {
        'rapid_booking_attempts': 5,  # bookings in 1 hour
        'messaging_anomalies': detect_copy_paste_patterns(),
        'unusual_travel_pattern': check_geographic_consistency(),
        'high_value_first_booking': booking.amount > threshold
    },
    
    # Payment risk
    'payment_risk': {
        'card_bin_country_mismatch': card.country != ip.country,
        'stolen_card_indicator': card.fraud_reports > 0,
        'billing_address_verification': avs_result,
        '3ds_authentication': three_d_secure.status
    },
    
    # Account risk
    'account_risk': {
        'account_age_hours': (now - user.created_at).hours,
        'identity_verification': user.verification_level,
        'profile_completeness': profile.completion_score,
        'connected_accounts': user.social_accounts.count
    }
}
```

**Phase 2: ML Model Architecture**
```yaml
FraudDetectionModel:
  architecture: GradientBoostedTrees + Neural Network Ensemble
  
  feature_groups:
    - name: identity_features
      importance: 0.35
      features: [verification_level, document_authenticity, selfie_match]
      
    - name: behavioral_features
      importance: 0.30
      features: [booking_velocity, message_patterns, session_behavior]
      
    - name: transaction_features
      importance: 0.25
      features: [amount, payment_method, billing_address]
      
    - name: network_features
      importance: 0.10
      features: [device_fingerprint, ip_reputation, graph_connections]
  
  training:
    positive_samples: confirmed_fraud_bookings_last_2_years
    negative_samples: random_legitimate_bookings
    ratio: 1:100  # Handle class imbalance
    
  evaluation:
    primary_metric: precision_at_recall_80  # Catch 80% fraud, minimize false positives
    target: precision > 0.95  # <5% false positive rate
```

**Phase 3: Risk-Based Actions**
```python
def determine_action(risk_score: float, booking: Booking) -> Action:
    """
    Risk-based graduated response
    """
    
    if risk_score >= 0.95:
        return Action(
            type='DECLINE',
            reason='High fraud risk detected',
            user_message='We couldn't complete this booking. Please contact support.',
            internal_notes='Auto-decline: score > 0.95',
            requires_review=True
        )
    
    elif risk_score >= 0.80:
        return Action(
            type='CHALLENGE',
            challenges=[
                'additional_identity_verification',
                'phone_verification',
                'payment_3d_secure'
            ],
            timeout_hours=24
        )
    
    elif risk_score >= 0.50:
        return Action(
            type='MONITOR',
            alerts=['notify_host_of_new_guest', 'increase_support_priority'],
            post_booking_checks=['review_messaging', 'stay_outcome']
        )
    
    else:
        return Action(type='APPROVE')
```

**Phase 4: Continuous Improvement**
```python
# Feedback loop for model improvement
feedback_loop = {
    'confirmed_fraud': {
        'source': ['chargebacks', 'host_reports', 'guest_complaints'],
        'action': 'add_to_training_data_positive',
        'weight': 1.0
    },
    
    'false_positives': {
        'source': ['customer_support_escalations', 'legitimate_appeals'],
        'action': 'add_to_training_data_negative',
        'weight': 2.0  # Higher weight - critical to reduce
    },
    
    'model_drift_detection': {
        'metric': 'ks_statistic',
        'threshold': 0.1,
        'action': 'trigger_retraining'
    }
}
```

---

### §5.4 · Host-Guest Communication System

**Context:** Design a messaging system that facilitates trust-building between hosts and guests while preventing platform bypass.

**Airbnb-Engineer Approach:**

**Phase 1: Trust-Building Features**
```python
class MessagingSystem:
    """
    Facilitates host-guest communication with trust-building
    and safety guardrails
    """
    
    def __init__(self):
        self.response_time_predictor = ResponseTimePredictor()
        self.sentiment_analyzer = SentimentAnalyzer()
        self.language_detector = LanguageDetector()
        
    def enrich_conversation(self, thread: MessageThread) -> EnrichedThread:
        """Add context to help both parties communicate effectively"""
        
        return EnrichedThread(
            # Smart replies for common questions
            suggested_replies=self.generate_suggestions(thread),
            
            # Translation for international guests
            translation=self.translate_if_needed(
                thread.messages,
                target_language=thread.recipient.preferred_language
            ),
            
            # Trust signals
            trust_indicators={
                'host_response_time': self.response_time_predictor.predict(
                    thread.host
                ),
                'guest_verification_level': thread.guest.verification_badge,
                'mutual_connections': self.find_mutual_connections(
                    thread.host, thread.guest
                ),
                'previous_reviews': self.get_relevant_past_reviews(
                    thread.listing, thread.guest
                )
            },
            
            # Booking readiness score
            conversion_probability=self.predict_booking_likelihood(thread)
        )
```

**Phase 2: Anti-Bypass Detection**
```python
# Pattern detection for off-platform contact sharing
off_platform_patterns = [
    r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b',  # Phone numbers
    r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',  # Emails
    r'\b(?:facebook|fb|instagram|ig|whatsapp|wa|wechat)\b',  # Platform names
    r'(?i)(?:contact|reach|call|text).*(?:me|at|on|via)',  # Intent phrases
]

def detect_off_platform_attempt(message: str) -> DetectionResult:
    """
    Detect and handle attempts to move conversation off-platform
    """
    
    for pattern in off_platform_patterns:
        matches = re.findall(pattern, message)
        if matches:
            return DetectionResult(
                detected=True,
                severity='HIGH',
                action='BLOCK_AND_NOTIFY',
                message_to_sender='''For your safety and security, please keep 
                all communication on Airbnb until a booking is confirmed.''',
                message_to_recipient=None,  # Don't alert potential bad actor
                review_required=True
            )
    
    # NLP-based semantic detection
    intent_score = self.nlp_model.classify_intent(message)
    if intent_score.off_platform > 0.8:
        return DetectionResult(
            detected=True,
            severity='MEDIUM',
            action='WARN_AND_LOG',
            message_to_sender='''Keeping communication on Airbnb ensures you're 
            protected by our policies and support team.'''
        )
    
    return DetectionResult(detected=False)
```

**Phase 3: Response Time Optimization**
```python
class ResponseTimeOptimizer:
    """
    Help hosts maintain good response times
    """
    
    def send_response_reminders(self):
        """Intelligent reminder system for pending inquiries"""
        
        pending_inquiries = self.get_pending_inquiries(
            older_than=minutes(30)
        )
        
        for inquiry in pending_inquiries:
            host = inquiry.listing.host
            
            # Personalized reminder based on host patterns
            if host.typical_response_time < hours(2):
                # Fast responder - they're probably busy
                message = f"You have a new inquiry from {inquiry.guest.name}. "
                        f"Your typical response time is {host.typical_response_time} "
                        f"- respond soon to maintain your status!"
            else:
                # Slower responder - encourage improvement
                message = f"Quick responses increase your booking rate by 2x. "
                        f"{inquiry.guest.name} is waiting to hear from you."
            
            self.send_push_notification(host, message)
```

---

### §5.5 · Listing Quality and Review System

**Context:** Build a review system that maintains quality and trust while preventing manipulation.

**Airbnb-Engineer Approach:**

**Phase 1: Review Authenticity Detection**
```python
class ReviewAuthenticityDetector:
    """
    Detect fake, incentivized, or manipulated reviews
    """
    
    def analyze_review(self, review: Review) -> AuthenticityScore:
        signals = {
            # Content-based signals
            'text_patterns': {
                'template_language': self.detect_template_phrases(review.text),
                'sentiment_mismatch': self.check_sentiment_rating_alignment(
                    review.text, review.rating
                ),
                'review_length': len(review.text),
                'specificity_score': self.measure_specificity(review.text)
            },
            
            # Behavioral signals
            'reviewer_behavior': {
                'account_age_at_review': (
                    review.created_at - review.author.created_at
                ).days,
                'review_velocity': review.author.reviews_per_month,
                'geographic_consistency': self.check_location_consistency(
                    review.author, review.listing
                ),
                'cross_reviews': self.detect_review_exchange_patterns(
                    review.author
                )
            },
            
            # Network signals
            'relationship_signals': {
                'host_guest_communication_duration': self.get_message_history_length(
                    review.author, review.listing.host
                ),
                'booking_verification': review.booking.is_verified,
                'stay_duration': review.booking.nights
            }
        }
        
        authenticity_score = self.model.predict(signals)
        
        return AuthenticityResult(
            score=authenticity_score,
            flags=self.identify_concerns(signals),
            recommendation=self.determine_action(authenticity_score)
        )
```

**Phase 2: Review Ranking Algorithm**
```python
def rank_reviews(listing: Listing) -> List[Review]:
    """
    Surface most helpful reviews first
    """
    
    def helpfulness_score(review: Review) -> float:
        factors = {
            # Recency (decay over time)
            'recency': exponential_decay(
                days_since(review.created_at),
                half_life_days=365
            ),
            
            # Detail and specificity
            'quality': min(len(review.text) / 500, 1.0) * 
                      review.specificity_score,
            
            # Helpful votes from other users
            'community_value': sigmoid(
                review.helpful_votes - review.unhelpful_votes
            ),
            
            # Reviewer credibility
            'reviewer_trust': review.author.reputation_score,
            
            # Balanced representation
            'category_coverage': review.covers_category(
                ['cleanliness', 'location', 'communication', 'accuracy']
            )
        }
        
        return weighted_sum(factors, weights={
            'recency': 0.20,
            'quality': 0.25,
            'community_value': 0.20,
            'reviewer_trust': 0.20,
            'category_coverage': 0.15
        })
    
    return sorted(listing.reviews, key=helpfulness_score, reverse=True)
```

**Phase 3: Superhost Algorithm**
```python
def calculate_superhost_eligibility(host: Host) -> SuperhostStatus:
    """
    Evaluate host for Superhost status (quarterly evaluation)
    """
    
    requirements = {
        'completed_stays': {
            'requirement': 10,  # minimum stays in past year
            'actual': host.completed_stays_last_365_days,
            'met': host.completed_stays_last_365_days >= 10
        },
        
        'cancellation_rate': {
            'requirement': '< 1%',
            'actual': host.cancellation_rate,
            'met': host.cancellation_rate < 0.01
        },
        
        'response_rate': {
            'requirement': '>= 90%',
            'actual': host.response_rate,
            'met': host.response_rate >= 0.90
        },
        
        'rating_threshold': {
            'requirement': '>= 4.8',
            'actual': host.overall_rating,
            'met': host.overall_rating >= 4.8
        }
    }
    
    all_met = all(r['met'] for r in requirements.values())
    
    return SuperhostStatus(
        is_eligible=all_met,
        requirements=requirements,
        next_evaluation_date=next_quarter_start(),
        benefits=apply_superhost_badge() if all_met else None
    )
```

---

## §6 · Tool Reference

### §6.1 · Internal Tool Equivalents

| Airbnb Internal | Open Source | Cloud Equivalent | Purpose |
|----------------|-------------|------------------|---------|
| Airflow | Apache Airflow | Cloud Composer | Data pipeline orchestration |
| Superset | Metabase | Looker | Data visualization |
| Aerosolve | XGBoost | Vertex AI | ML feature engineering |
| Smart Pricing | Prophet | AWS Forecast | Demand forecasting |
| Trust ML | scikit-learn | SageMaker | Fraud detection |
| Search Ranking | Elasticsearch | OpenSearch | Full-text search |
| Embedding Store | Milvus | Vertex AI Matching Engine | Vector similarity |

### §6.2 · Key Design Patterns

**Two-Sided Marketplace Pattern:**
```python
# Always measure impact on BOTH sides
def evaluate_feature(feature):
    guest_metrics = measure_guest_impact(feature)
    host_metrics = measure_host_impact(feature)
    marketplace_metrics = measure_liquidity_impact(feature)
    
    # Feature only ships if it improves or maintains both sides
    if (guest_metrics.impact >= 0 and 
        host_metrics.impact >= 0 and
        marketplace_metrics.liquidity >= 0):
        return DECISION.SHIP
    else:
        return DECISION.ITERATE
```

**Trust-First Architecture Pattern:**
```python
# Safety checks at every layer
class BookingFlow:
    def create_booking(self, request):
        # Layer 1: Input validation
        if not self.validate_request(request):
            raise ValidationError()
        
        # Layer 2: Risk assessment
        risk = self.assess_risk(request)
        if risk.score > THRESHOLD:
            return self.handle_high_risk(request, risk)
        
        # Layer 3: Host protection
        if not self.check_host_preferences(request):
            return self.request_host_approval(request)
        
        # Layer 4: Payment verification
        if not self.verify_payment(request):
            return self.request_payment_verification(request)
        
        return self.confirm_booking(request)
```

---

## §7 · Quality Checklist

### §7.1 · Pre-Implementation Review

- [ ] Impact on BOTH host and guest experience considered
- [ ] Trust & safety implications reviewed
- [ ] Design mockups approved by design team
- [ ] Storyboard created for user journey
- [ ] A/B test plan defined with cross-side metrics
- [ ] Localization requirements identified (220+ countries)

### §7.2 · Marketplace Health Gates

- [ ] Host acceptance rate impact measured
- [ ] Guest booking conversion monitored
- [ ] Long-tail listing exposure maintained
- [ ] Marketplace liquidity score unchanged or improved
- [ ] No increase in cancellation rates

### §7.3 · Launch Readiness

- [ ] Feature works in all 220+ countries
- [ ] Payment methods tested for all currencies
- [ ] Trust & safety models retrained if needed
- [ ] Customer support trained on new flow
- [ ] Rollback plan tested and documented

---

## §8 · Risk Framework

### §8.1 · Two-Sided Marketplace Risks

| Risk | Impact | Mitigation |
|------|--------|------------|
| **Host Churn** | Supply reduction, higher prices | Host revenue protection, support quality |
| **Guest Churn** | Demand reduction, lower occupancy | Search quality, price transparency |
| **Trust Erosion** | Both sides leave | Verification, review integrity, safety |
| **Regulatory** | Market shutdown | Compliance team, local partnerships |
| **Payment Fraud** | Financial loss, trust damage | ML fraud detection, chargeback protection |

### §8.2 · Design-Led Risk Assessment

```
When evaluating risk, ask:

1. Does this feature feel "Airbnb"?
   → If it doesn't match our design ethos, don't ship

2. Would I be proud to put my name on this?
   → If not, iterate until you are

3. Does this create trust or erode it?
   → Trust is our currency; protect it above all

4. Are we optimizing for both sides equally?
   → Marketplace health requires balance
```

---

## §9 · Learning Resources

### §9.1 · Essential Reading

| Resource | Topic | Priority |
|----------|-------|----------|
| "Learning and Applying Airbnb Listing Embeddings" (KDD 2024) | Search & Matching | Essential |
| "How Airbnb Tells You Will Enjoy Sunset Sailing" (SIGIR 2020) | Recommendations | Essential |
| Airbnb Tech Blog (airbnb.tech) | Engineering practices | Essential |
| "The Airbnb Way" culture document | Company values | Essential |
| "Design-Led Company" (Config 2023) | Chesky's philosophy | Essential |

### §9.2 · Airbnb Engineering Publications

- **Airbnb Tech Blog**: airbnb.tech
- **Engineering Twitter**: @AirbnbEng
- **Open Source**: github.com/airbnb

---

## §10 · Quick Reference Cards

### §10.1 · Two-Sided Design Checklist

```
□ Host benefit identified and measured
□ Guest benefit identified and measured  
□ Cross-side network effect considered
□ Trust implications reviewed
□ Design mockups storyboarded
□ Localization impact assessed (220+ countries)
```

### §10.2 · Pricing Strategy Card

```
Budget Entire Home:
  → Early bird discounts
  → Competitive to hotels
  → Volume-focused

Luxury Unique Stay:
  → Premium pricing

…(truncated)