@hybridlabor-api/bdb-antigravity-skills 1.0.0

package/skills/global_config/product-manager-toolkit/scripts/rice_prioritizer.py

@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+"""
+RICE Prioritization Framework
+Calculates RICE scores for feature prioritization
+RICE = (Reach x Impact x Confidence) / Effort
+"""
+
+import json
+import csv
+from typing import List, Dict, Tuple
+import argparse
+
+class RICECalculator:
+    """Calculate RICE scores for feature prioritization"""
+    
+    def __init__(self):
+        self.impact_map = {
+            'massive': 3.0,
+            'high': 2.0,
+            'medium': 1.0,
+            'low': 0.5,
+            'minimal': 0.25
+        }
+        
+        self.confidence_map = {
+            'high': 100,
+            'medium': 80,
+            'low': 50
+        }
+        
+        self.effort_map = {
+            'xl': 13,
+            'l': 8,
+            'm': 5,
+            's': 3,
+            'xs': 1
+        }
+    
+    def calculate_rice(self, reach: int, impact: str, confidence: str, effort: str) -> float:
+        """
+        Calculate RICE score
+        
+        Args:
+            reach: Number of users/customers affected per quarter
+            impact: massive/high/medium/low/minimal
+            confidence: high/medium/low (percentage)
+            effort: xl/l/m/s/xs (person-months)
+        """
+        impact_score = self.impact_map.get(impact.lower(), 1.0)
+        confidence_score = self.confidence_map.get(confidence.lower(), 50) / 100
+        effort_score = self.effort_map.get(effort.lower(), 5)
+        
+        if effort_score == 0:
+            return 0
+        
+        rice_score = (reach * impact_score * confidence_score) / effort_score
+        return round(rice_score, 2)
+    
+    def prioritize_features(self, features: List[Dict]) -> List[Dict]:
+        """
+        Calculate RICE scores and rank features
+        
+        Args:
+            features: List of feature dictionaries with RICE components
+        """
+        for feature in features:
+            feature['rice_score'] = self.calculate_rice(
+                feature.get('reach', 0),
+                feature.get('impact', 'medium'),
+                feature.get('confidence', 'medium'),
+                feature.get('effort', 'm')
+            )
+        
+        # Sort by RICE score descending
+        return sorted(features, key=lambda x: x['rice_score'], reverse=True)
+    
+    def analyze_portfolio(self, features: List[Dict]) -> Dict:
+        """
+        Analyze the feature portfolio for balance and insights
+        """
+        if not features:
+            return {}
+        
+        total_effort = sum(
+            self.effort_map.get(f.get('effort', 'm').lower(), 5) 
+            for f in features
+        )
+        
+        total_reach = sum(f.get('reach', 0) for f in features)
+        
+        effort_distribution = {}
+        impact_distribution = {}
+        
+        for feature in features:
+            effort = feature.get('effort', 'm').lower()
+            impact = feature.get('impact', 'medium').lower()
+            
+            effort_distribution[effort] = effort_distribution.get(effort, 0) + 1
+            impact_distribution[impact] = impact_distribution.get(impact, 0) + 1
+        
+        # Calculate quick wins (high impact, low effort)
+        quick_wins = [
+            f for f in features 
+            if f.get('impact', '').lower() in ['massive', 'high'] 
+            and f.get('effort', '').lower() in ['xs', 's']
+        ]
+        
+        # Calculate big bets (high impact, high effort)
+        big_bets = [
+            f for f in features 
+            if f.get('impact', '').lower() in ['massive', 'high'] 
+            and f.get('effort', '').lower() in ['l', 'xl']
+        ]
+        
+        return {
+            'total_features': len(features),
+            'total_effort_months': total_effort,
+            'total_reach': total_reach,
+            'average_rice': round(sum(f['rice_score'] for f in features) / len(features), 2),
+            'effort_distribution': effort_distribution,
+            'impact_distribution': impact_distribution,
+            'quick_wins': len(quick_wins),
+            'big_bets': len(big_bets),
+            'quick_wins_list': quick_wins[:3],  # Top 3 quick wins
+            'big_bets_list': big_bets[:3]  # Top 3 big bets
+        }
+    
+    def generate_roadmap(self, features: List[Dict], team_capacity: int = 10) -> List[Dict]:
+        """
+        Generate a quarterly roadmap based on team capacity
+        
+        Args:
+            features: Prioritized feature list
+            team_capacity: Person-months available per quarter
+        """
+        quarters = []
+        current_quarter = {
+            'quarter': 1,
+            'features': [],
+            'capacity_used': 0,
+            'capacity_available': team_capacity
+        }
+        
+        for feature in features:
+            effort = self.effort_map.get(feature.get('effort', 'm').lower(), 5)
+            
+            if current_quarter['capacity_used'] + effort <= team_capacity:
+                current_quarter['features'].append(feature)
+                current_quarter['capacity_used'] += effort
+            else:
+                # Move to next quarter
+                current_quarter['capacity_available'] = team_capacity - current_quarter['capacity_used']
+                quarters.append(current_quarter)
+                
+                current_quarter = {
+                    'quarter': len(quarters) + 1,
+                    'features': [feature],
+                    'capacity_used': effort,
+                    'capacity_available': team_capacity - effort
+                }
+        
+        if current_quarter['features']:
+            current_quarter['capacity_available'] = team_capacity - current_quarter['capacity_used']
+            quarters.append(current_quarter)
+        
+        return quarters
+
+def format_output(features: List[Dict], analysis: Dict, roadmap: List[Dict]) -> str:
+    """Format the results for display"""
+    output = ["=" * 60]
+    output.append("RICE PRIORITIZATION RESULTS")
+    output.append("=" * 60)
+    
+    # Top prioritized features
+    output.append("\n📊 TOP PRIORITIZED FEATURES\n")
+    for i, feature in enumerate(features[:10], 1):
+        output.append(f"{i}. {feature.get('name', 'Unnamed')}")
+        output.append(f"   RICE Score: {feature['rice_score']}")
+        output.append(f"   Reach: {feature.get('reach', 0)} | Impact: {feature.get('impact', 'medium')} | "
+                     f"Confidence: {feature.get('confidence', 'medium')} | Effort: {feature.get('effort', 'm')}")
+        output.append("")
+    
+    # Portfolio analysis
+    output.append("\n📈 PORTFOLIO ANALYSIS\n")
+    output.append(f"Total Features: {analysis.get('total_features', 0)}")
+    output.append(f"Total Effort: {analysis.get('total_effort_months', 0)} person-months")
+    output.append(f"Total Reach: {analysis.get('total_reach', 0):,} users")
+    output.append(f"Average RICE Score: {analysis.get('average_rice', 0)}")
+    
+    output.append(f"\n🎯 Quick Wins: {analysis.get('quick_wins', 0)} features")
+    for qw in analysis.get('quick_wins_list', []):
+        output.append(f"   • {qw.get('name', 'Unnamed')} (RICE: {qw['rice_score']})")
+    
+    output.append(f"\n🚀 Big Bets: {analysis.get('big_bets', 0)} features")
+    for bb in analysis.get('big_bets_list', []):
+        output.append(f"   • {bb.get('name', 'Unnamed')} (RICE: {bb['rice_score']})")
+    
+    # Roadmap
+    output.append("\n\n📅 SUGGESTED ROADMAP\n")
+    for quarter in roadmap:
+        output.append(f"\nQ{quarter['quarter']} - Capacity: {quarter['capacity_used']}/{quarter['capacity_used'] + quarter['capacity_available']} person-months")
+        for feature in quarter['features']:
+            output.append(f"   • {feature.get('name', 'Unnamed')} (RICE: {feature['rice_score']})")
+    
+    return "\n".join(output)
+
+def load_features_from_csv(filepath: str) -> List[Dict]:
+    """Load features from CSV file"""
+    features = []
+    with open(filepath, 'r') as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            feature = {
+                'name': row.get('name', ''),
+                'reach': int(row.get('reach', 0)),
+                'impact': row.get('impact', 'medium'),
+                'confidence': row.get('confidence', 'medium'),
+                'effort': row.get('effort', 'm'),
+                'description': row.get('description', '')
+            }
+            features.append(feature)
+    return features
+
+def create_sample_csv(filepath: str):
+    """Create a sample CSV file for testing"""
+    sample_features = [
+        ['name', 'reach', 'impact', 'confidence', 'effort', 'description'],
+        ['User Dashboard Redesign', '5000', 'high', 'high', 'l', 'Complete redesign of user dashboard'],
+        ['Mobile Push Notifications', '10000', 'massive', 'medium', 'm', 'Add push notification support'],
+        ['Dark Mode', '8000', 'medium', 'high', 's', 'Implement dark mode theme'],
+        ['API Rate Limiting', '2000', 'low', 'high', 'xs', 'Add rate limiting to API'],
+        ['Social Login', '12000', 'high', 'medium', 'm', 'Add Google/Facebook login'],
+        ['Export to PDF', '3000', 'medium', 'low', 's', 'Export reports as PDF'],
+        ['Team Collaboration', '4000', 'massive', 'low', 'xl', 'Real-time collaboration features'],
+        ['Search Improvements', '15000', 'high', 'high', 'm', 'Enhance search functionality'],
+        ['Onboarding Flow', '20000', 'massive', 'high', 's', 'Improve new user onboarding'],
+        ['Analytics Dashboard', '6000', 'high', 'medium', 'l', 'Advanced analytics for users'],
+    ]
+    
+    with open(filepath, 'w', newline='') as f:
+        writer = csv.writer(f)
+        writer.writerows(sample_features)
+    
+    print(f"Sample CSV created at: {filepath}")
+
+def main():
+    parser = argparse.ArgumentParser(description='RICE Framework for Feature Prioritization')
+    parser.add_argument('input', nargs='?', help='CSV file with features or "sample" to create sample')
+    parser.add_argument('--capacity', type=int, default=10, help='Team capacity per quarter (person-months)')
+    parser.add_argument('--output', choices=['text', 'json', 'csv'], default='text', help='Output format')
+    
+    args = parser.parse_args()
+    
+    # Create sample if requested
+    if args.input == 'sample':
+        create_sample_csv('sample_features.csv')
+        return
+    
+    # Use sample data if no input provided
+    if not args.input:
+        features = [
+            {'name': 'User Dashboard', 'reach': 5000, 'impact': 'high', 'confidence': 'high', 'effort': 'l'},
+            {'name': 'Push Notifications', 'reach': 10000, 'impact': 'massive', 'confidence': 'medium', 'effort': 'm'},
+            {'name': 'Dark Mode', 'reach': 8000, 'impact': 'medium', 'confidence': 'high', 'effort': 's'},
+            {'name': 'API Rate Limiting', 'reach': 2000, 'impact': 'low', 'confidence': 'high', 'effort': 'xs'},
+            {'name': 'Social Login', 'reach': 12000, 'impact': 'high', 'confidence': 'medium', 'effort': 'm'},
+        ]
+    else:
+        features = load_features_from_csv(args.input)
+    
+    # Calculate RICE scores
+    calculator = RICECalculator()
+    prioritized = calculator.prioritize_features(features)
+    analysis = calculator.analyze_portfolio(prioritized)
+    roadmap = calculator.generate_roadmap(prioritized, args.capacity)
+    
+    # Output results
+    if args.output == 'json':
+        result = {
+            'features': prioritized,
+            'analysis': analysis,
+            'roadmap': roadmap
+        }
+        print(json.dumps(result, indent=2))
+    elif args.output == 'csv':
+        # Output prioritized features as CSV
+        if prioritized:
+            keys = prioritized[0].keys()
+            print(','.join(keys))
+            for feature in prioritized:
+                print(','.join(str(feature.get(k, '')) for k in keys))
+    else:
+        print(format_output(prioritized, analysis, roadmap))
+
+if __name__ == "__main__":
+    main()

package/skills/global_config/programmatic-seo/SKILL.md

@@ -0,0 +1,356 @@
+---
+name: programmatic-seo
+description: Design and evaluate programmatic SEO strategies for creating SEO-driven pages at scale using templates and structured data.
+risk: unknown
+source: community
+date_added: '2026-02-27'
+---
+
+---
+
+# Programmatic SEO
+
+You are an expert in **programmatic SEO strategy**—designing systems that generate
+**useful, indexable, search-driven pages at scale** using templates and structured data.
+
+Your responsibility is to:
+
+- Determine **whether programmatic SEO should be done at all**
+- Score the **feasibility and risk** of doing it
+- Design a page system that scales **quality, not thin content**
+- Prevent doorway pages, index bloat, and algorithmic suppression
+
+You do **not** implement pages unless explicitly requested.
+
+---
+
+## Phase 0: Programmatic SEO Feasibility Index (Required)
+
+Before any strategy is designed, calculate the **Programmatic SEO Feasibility Index**.
+
+### Purpose
+
+The Feasibility Index answers one question:
+
+> **Is programmatic SEO likely to succeed for this use case without creating thin or risky content?**
+
+---
+
+## 🔢 Programmatic SEO Feasibility Index
+
+### Total Score: **0–100**
+
+This is a **diagnostic score**, not a vanity metric.
+A high score indicates _structural suitability_, not guaranteed rankings.
+
+---
+
+### Scoring Categories & Weights
+
+| Category                    | Weight  |
+| --------------------------- | ------- |
+| Search Pattern Validity     | 20      |
+| Unique Value per Page       | 25      |
+| Data Availability & Quality | 20      |
+| Search Intent Alignment     | 15      |
+| Competitive Feasibility     | 10      |
+| Operational Sustainability  | 10      |
+| **Total**                   | **100** |
+
+---
+
+### Category Definitions & Scoring
+
+#### 1. Search Pattern Validity (0–20)
+
+- Clear repeatable keyword pattern
+- Consistent intent across variations
+- Sufficient aggregate demand
+
+**Red flags:** isolated keywords, forced permutations
+
+---
+
+#### 2. Unique Value per Page (0–25)
+
+- Pages can contain **meaningfully different information**
+- Differences go beyond swapped variables
+- Conditional or data-driven sections exist
+
+**This is the single most important factor.**
+
+---
+
+#### 3. Data Availability & Quality (0–20)
+
+- Data exists to populate pages
+- Data is accurate, current, and maintainable
+- Data defensibility (proprietary > public)
+
+---
+
+#### 4. Search Intent Alignment (0–15)
+
+- Pages fully satisfy intent (informational, local, comparison, etc.)
+- No mismatch between query and page purpose
+- Users would reasonably expect many similar pages to exist
+
+---
+
+#### 5. Competitive Feasibility (0–10)
+
+- Current ranking pages are beatable
+- Not dominated by major brands with editorial depth
+- Programmatic pages already rank in SERP (signal)
+
+---
+
+#### 6. Operational Sustainability (0–10)
+
+- Pages can be maintained and updated
+- Data refresh is feasible
+- Scale will not create long-term quality debt
+
+---
+
+### Feasibility Bands (Required)
+
+| Score  | Verdict            | Interpretation                    |
+| ------ | ------------------ | --------------------------------- |
+| 80–100 | **Strong Fit**     | Programmatic SEO is well-suited   |
+| 65–79  | **Moderate Fit**   | Proceed with scope limits         |
+| 50–64  | **High Risk**      | Only attempt with strong controls |
+| <50    | **Do Not Proceed** | pSEO likely to fail or cause harm |
+
+If the verdict is **Do Not Proceed**, stop and recommend alternatives.
+
+---
+
+## Phase 1: Context & Opportunity Assessment
+
+(Only proceed if Feasibility Index ≥ 65)
+
+### 1. Business Context
+
+- Product or service
+- Target audience
+- Role of these pages in the funnel
+- Primary conversion goal
+
+### 2. Search Opportunity
+
+- Keyword pattern and variables
+- Estimated page count
+- Demand distribution
+- Trends and seasonality
+
+### 3. Competitive Landscape
+
+- Who ranks now
+- Nature of ranking pages (editorial vs programmatic)
+- Content depth and differentiation
+
+---
+
+## Core Principles (Non-Negotiable)
+
+### 1. Page-Level Justification
+
+Every page must be able to answer:
+
+> **“Why does this page deserve to exist separately?”**
+
+If the answer is unclear, the page should not be indexed.
+
+---
+
+### 2. Data Defensibility Hierarchy
+
+1. Proprietary
+2. Product-derived
+3. User-generated
+4. Licensed (exclusive)
+5. Public (weakest)
+
+Weaker data requires **stronger editorial value**.
+
+---
+
+### 3. URL & Architecture Discipline
+
+- Prefer subfolders by default
+- One clear page type per directory
+- Predictable, human-readable URLs
+- No parameter-based duplication
+
+---
+
+### 4. Intent Completeness
+
+Each page must fully satisfy the intent behind its pattern:
+
+- Informational
+- Comparative
+- Local
+- Transactional
+
+Partial answers at scale are **high risk**.
+
+---
+
+### 5. Quality at Scale
+
+Scaling pages does **not** lower the bar for quality.
+
+100 excellent pages > 10,000 weak ones.
+
+---
+
+### 6. Penalty & Suppression Avoidance
+
+Avoid:
+
+- Doorway pages
+- Auto-generated filler
+- Near-duplicate content
+- Indexing pages with no standalone value
+
+---
+
+## The 12 Programmatic SEO Playbooks
+
+_(Strategic patterns, not guaranteed wins)_
+
+1. Templates
+2. Curation
+3. Conversions
+4. Comparisons
+5. Examples
+6. Locations
+7. Personas
+8. Integrations
+9. Glossary
+10. Translations
+11. Directories
+12. Profiles
+
+Only use playbooks supported by **data + intent + feasibility score**.
+
+---
+
+## Phase 2: Page System Design
+
+### 1. Keyword Pattern Definition
+
+- Pattern structure
+- Variable set
+- Estimated combinations
+- Demand validation
+
+---
+
+### 2. Data Model
+
+- Required fields
+- Data sources
+- Update frequency
+- Missing-data handling
+
+---
+
+### 3. Template Specification
+
+- Mandatory sections
+- Conditional logic
+- Unique content mechanisms
+- Internal linking rules
+- Index / noindex criteria
+
+---
+
+## Phase 3: Indexation & Scale Control
+
+### Indexation Rules
+
+- Not all generated pages should be indexed
+- Index only pages with:
+  - Demand
+  - Unique value
+  - Complete intent match
+
+### Crawl Management
+
+- Avoid crawl traps
+- Segment sitemaps by page type
+- Monitor indexation rate by pattern
+
+---
+
+## Quality Gates (Mandatory)
+
+### Pre-Index Checklist
+
+- Unique value demonstrated
+- Intent fully satisfied
+- No near-duplicates
+- Performance acceptable
+- Canonicals correct
+
+---
+
+### Kill Switch Criteria
+
+If triggered, **halt indexing or roll back**:
+
+- High impressions, low engagement at scale
+- Thin content warnings
+- Index bloat with no traffic
+- Manual or algorithmic suppression signals
+
+---
+
+## Output Format (Required)
+
+### Programmatic SEO Strategy
+
+**Feasibility Index**
+
+- Overall Score: XX / 100
+- Verdict: Strong Fit / Moderate Fit / High Risk / Do Not Proceed
+- Category breakdown with brief rationale
+
+**Opportunity Summary**
+
+- Keyword pattern
+- Estimated scale
+- Competition overview
+
+**Page System Design**
+
+- URL pattern
+- Data requirements
+- Template outline
+- Indexation rules
+
+**Risks & Mitigations**
+
+- Thin content risk
+- Data quality risk
+- Crawl/indexation risk
+
+---
+
+## Related Skills
+
+- **seo-audit** – Audit programmatic pages post-launch
+- **schema-markup** – Add structured data to templates
+- **copywriting** – Improve non-templated sections
+- **analytics-tracking** – Measure performance and validate value
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.
+
+## Limitations
+- Use this skill only when the task clearly matches the scope described above.
+- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
+- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.