# Growth Engine > Use when autonomous marketing experiment framework — design A/B tests, score hypotheses with ICE, validate results with statistical significance, and run automated optimization loops. - Skill: `oyi77/growth-engine` (Agent Skill) - Install (CLI): `npx skillmds add oyi77/growth-engine` - Raw SKILL.md: https://api.skillmd.com/api/skills/oyi77/growth-engine/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Marketing & Growth - License: Apache-2.0 - Author: oyi77 (https://skillmd.com/u/oyi77) - Updated: 2026-09-08 - Page: https://skillmd.com/skills/oyi77/growth-engine --- # Growth Engine ## When to Use **Trigger phrases:** - "growth engine" - "Help me with growth engine" **Use cases:** - When the task matches this skill's domain expertise **When NOT to use:** - For tasks outside this skill's scope hypothesis = growth_hypothesis( insight="Users who view demo video convert 3x higher", design="Add prominent demo CTA on homepage", expected="+25% demo views, +15% trial signups", assumption="Demo video quality resonates with target audience" ) # 2. Design experiment experiment = design_ab_test( hypothesis=hypothesis, variants=["demo_cta_v1", "demo_cta_v2"], primary_metric="trial_signup_rate", secondary_metrics=["demo_view_rate", "time_on_page"], traffic_split=[0.34, 0.33, 0.33] # Control + 2 variants ) # 3. Launch and monitor experiment.launch() while experiment.status == "RUNNING": daily_report = experiment.generate_report() # Check pacing alerts if daily_report.sample_size_alert: notify("Sample size behind pace") if daily_report.conversion_drop: experiment.pause() notify("Conversion rate anomaly detected") time.sleep(86400) # Daily check # 4. Analyze results results = experiment.final_analysis() if results.winner and results.confidence >= 0.95: implement_winner(results.winner) document_learning(results) else: document_learning(results) # Document negative result too ``` ### Example 2: Rapid Experiment Pipeline ```python # Run multiple micro-experiments in parallel experiments = [ {"type": "email_subject", "n_variants": 5, "traffic": "10%"}, {"type": "cta_color", "n_variants": 4, "traffic": "20%"}, {"type": "pricing_display", "n_variants": 3, "traffic": "30%"} ] for exp_config in experiments: exp = create_micro_experiment(exp_config) exp.launch() # Weekly review candidates = [] for exp in running_experiments: results = exp.get_results() if results.confidence >= 0.90: candidates.append(results) # Promote winners for winner in candidates: rollout_gradually(winner.variant, [0.10, 0.50, 1.0]) ``` ### Example 3: Growth Scorecard ```python # Generate weekly growth report scorecard = { "experiments": { "running": 8, "completed_this_week": 3, "winners": 1, "inconclusive": 2 }, "metrics": { "activation_rate": {"current": 0.35, "lift": "+5%"}, "retention_d7": {"current": 0.42, "lift": "+3%"}, "referral_rate": {"current": 0.18, "lift": "+12%"} }, "velocity": { "experiments_per_week": 2.5, "win_rate": 0.33, "avg_lift": "8.5%" } } generate_weekly_scorecard(scorecard) ``` --- ## When NOT to Use - When the audience is too small to justify the effort - For regulated industries without compliance review - When the campaign budget does not support the channel ## Overview Growth Engine drives growth marketing with data-driven strategies. ## Workflow 1. **Research** — Analyze market, competitors, and audience 2. **Strategy** — Define goals, channels, and messaging 3. **Create** — Develop content and creative assets 4. **Launch** — Deploy campaigns across channels 5. **Optimize** — A/B test and iterate based on data 6. **Report** — Track KPIs and ROI ## Key Metrics - Reach and impressions - Engagement rate (likes, shares, comments) - Conversion rate (clicks → leads → customers) - Customer acquisition cost (CAC) - Return on ad spend (ROAS) ## Best Practices - Test everything — headlines, images, CTAs, timing - Focus on one channel at a time, then expand - Build organic before scaling paid - Track attribution across the full funnel ## Anti-Rationalization Table | Rationalization | Reality | |---|---| | "Good products sell themselves" | They do not. Marketing is how people discover your product. | | "I will start marketing after launch" | Build audience before launch. Pre-launch momentum is critical. | | "SEO is dead" | SEO evolves. GEO (Generative Engine Optimization) is the new frontier. | ## Money-Making Overview Run automated growth experiments that compound revenue. Each completed experiment with statistically significant winner generates 10-50% lift on the tested metric. ## Revenue Streams - **Conversion optimization** — $1,000-$10,000/month per client - **Growth consulting** — $200-$500/hour - **Experiment-as-a-Service** — $2,000-$10,000/month - **Own product experiments** — $5,000-$50,000/month ## First Action in 60 Minutes ```python #!/usr/bin/env python3 """ICE hypothesis scoring framework — analyze metrics and rank experiment backlog.""" import json import sys from dataclasses import dataclass, field from typing import List, Optional @dataclass class ExperimentHypothesis: name: str description: str impact: int # 1-10 confidence: int # 1-10 ease: int # 1-10 def ice_score(self) -> float: return (self.impact + self.confidence + self.ease) / 3.0 def expected_revenue_impact(self, monthly_revenue: float, metric_share: float = 0.1) -> float: lift = self.impact * 0.05 # Each impact point ≈ 5% estimated lift return monthly_revenue * metric_share * lift def load_hypotheses(path: str) -> List[ExperimentHypothesis]: with open(path) as f: data = json.load(f) return [ExperimentHypothesis(**h) for h in data] def rank_experiments(hypotheses: List[ExperimentHypothesis], monthly_revenue: float) -> List[dict]: scored = [] for h in hypotheses: scored.append({ "name": h.name, "description": h.description, "ice_score": round(h.ice_score(), 2), "impact": h.impact, "confidence": h.confidence, "ease": h.ease, "expected_monthly_revenue_impact": round(h.expected_revenue_impact(monthly_revenue), 2) }) scored.sort(key=lambda x: x["ice_score"], reverse=True) return scored if __name__ == "__main__": if len(sys.argv) < 2: print("Usage: python ice_scorer.py [monthly_revenue]") sys.exit(1) revenue = float(sys.argv[2]) if len(sys.argv) > 2 else 50000.0 hypotheses = load_hypotheses(sys.argv[1]) ranked = rank_experiments(hypotheses, revenue) print("=" * 72) print("ICE SCORE RANKING — Experiment Backlog (by priority)") print("=" * 72) for i, exp in enumerate(ranked, 1): print(f"\n {i}. {exp['name']}") print(f" ICE: {exp['ice_score']:.1f} (Impact={exp['impact']} Confidence={exp['confidence']} Ease={exp['ease']})") print(f" Expected monthly impact: ${exp['expected_monthly_revenue_impact']:,.2f}") print(f" {exp['description']}") total = sum(e['expected_monthly_revenue_impact'] for e in ranked) print(f"\n{'─' * 72}") print(f" Total expected lift from backlog: ${total:,.2f}/month") print(f"{'─' * 72}") print("\nRun order: top ICE score first. Re-score weekly as data accumulates.") ``` ## Output Format ```yaml experiment_backlog: total_hypotheses: 12 top_ice_score: 8.3 total_expected_lift_monthly: "$12,500" top_3: - name: "Homepage demo CTA" ice: 8.3 expected_impact: "$3,750/mo" - name: "Email subject line A/B" ice: 7.7 expected_impact: "$2,500/mo" - name: "Pricing page redesign" ice: 7.0 expected_impact: "$1,875/mo" money_metric: "lift_on_target_kpi" ``` ## Process 1. **Prepare** — Gather requirements, verify prerequisites, set up environment 1. **Execute** — Run growth engine workflow with configured parameters 1. **Verify** — Validate output meets requirements, document results ## Verification - [ ] All steps executed successfully - [ ] Results validated against acceptance criteria - [ ] Error handling tested with edge cases - [ ] Documentation updated with findings