Imported from reason-machines/marketing-skills (skills/ai-marketing-skills-automation/SKILL.md) via skills.sh. Install upstream with npx skills add reason-machines/marketing-skills --skill ai-marketing-skills-automation. Copyright stays with the author.

AI Marketing Skills Automation

Skill by ara.so — Marketing Skills collection.

This project provides battle-tested marketing automation workflows — not prompts, but complete Python scripts with scoring algorithms, expert panels, and automation pipelines. Built for Claude Code and other AI coding agents to execute real marketing operations.

What It Does

AI Marketing Skills gives you 15+ categories of marketing automation:

Growth Engine: Autonomous experiments with statistical testing
Sales Pipeline: Website visitor → qualified pipeline automation
Content Ops: Quality scoring and production workflows
Outbound Engine: ICP definition to cold emails
SEO Ops: Content gap analysis and keyword research
Finance Ops: AI CFO for cost analysis
Revenue Intelligence: Sales call insights and attribution
Conversion Ops: CRO audits and lead magnet generation
Podcast Ops: Episode → multi-platform content
Sales Playbook: Value-based pricing frameworks
Autoresearch: Evolutionary content optimization
Deck Generator: AI slide deck creation
YT Competitive Analysis: YouTube outlier detection
X Long-Form: Human-sounding X/Twitter posts

Installation

# Clone the repository
git clone https://github.com/ericosiu/ai-marketing-skills.git
cd ai-marketing-skills

# Navigate to a specific skill category
cd growth-engine  # or sales-pipeline, content-ops, etc.

# Install dependencies for that category
pip install -r requirements.txt

# Set up environment variables
cp .env.example .env

Configuration

Each category uses a .env file for API keys and configuration:

# Common environment variables across skills
ANTHROPIC_API_KEY=your_anthropic_key_here
OPENAI_API_KEY=your_openai_key_here

# Growth Engine specific
GOOGLE_ANALYTICS_KEY=your_ga_key
LINKEDIN_API_KEY=your_linkedin_key

# Sales Pipeline specific
RB2B_API_KEY=your_rb2b_key
INSTANTLY_API_KEY=your_instantly_key
APOLLO_API_KEY=your_apollo_key

# SEO Ops specific
GOOGLE_SEARCH_CONSOLE_CREDENTIALS=path/to/credentials.json

# Revenue Intelligence specific
GONG_API_KEY=your_gong_key
SALESFORCE_API_KEY=your_salesforce_key

Growth Engine

Run autonomous marketing experiments with statistical rigor.

Experiment Engine

from experiment_engine import ExperimentEngine

# Initialize the engine
engine = ExperimentEngine(
    api_key=os.getenv("ANTHROPIC_API_KEY"),
    data_source="google_analytics"
)

# Create an experiment
experiment = engine.create_experiment(
    hypothesis="Thread posts get 2x engagement vs single posts",
    variable="format",
    variants=["thread", "single"],
    metric="impressions",
    duration_days=14,
    traffic_split=0.5
)

# Run the experiment
results = engine.run_experiment(experiment.id)

# Get statistical significance
analysis = engine.analyze_results(
    experiment.id,
    confidence_level=0.95,
    test_method="mann_whitney"
)

print(f"Winner: {analysis['winner']}")
print(f"P-value: {analysis['p_value']}")
print(f"Confidence: {analysis['confidence_interval']}")

Pacing Alerts

from pacing_alert import PacingMonitor

monitor = PacingMonitor(
    budget_monthly=10000,
    platform="linkedin"
)

# Check daily pacing
alert = monitor.check_pacing(
    spend_to_date=3500,
    days_elapsed=8,
    days_in_month=30
)

if alert['status'] == 'overpacing':
    print(f"Alert: Overpacing by {alert['variance_percent']}%")
    print(f"Recommended daily spend: ${alert['recommended_daily']}")

CLI Usage

# Create experiment
python experiment-engine.py create \
  --hypothesis "Carousel posts outperform static images" \
  --variable post_type \
  --variants '["carousel", "static"]' \
  --metric engagement_rate \
  --duration 14

# Check pacing
python pacing-alert.py check \
  --budget 10000 \
  --spend 3500 \
  --days-elapsed 8

# Generate weekly scorecard
python autogrowth-weekly-scorecard.py generate \
  --start-date 2026-05-01 \
  --end-date 2026-05-07

Sales Pipeline

Turn anonymous website visitors into qualified pipeline.

RB2B Router

from rb2b_instantly_router import RB2BRouter

router = RB2BRouter(
    rb2b_key=os.getenv("RB2B_API_KEY"),
    instantly_key=os.getenv("INSTANTLY_API_KEY")
)

# Fetch website visitors from RB2B
visitors = router.fetch_visitors(
    lookback_hours=24,
    min_intent_score=7
)

# Route to Instantly campaigns
for visitor in visitors:
    # Score and enrich
    enriched = router.enrich_visitor(visitor)
    
    # Route based on criteria
    if enriched['seniority'] in ['C-Level', 'VP', 'Director']:
        router.add_to_campaign(
            email=enriched['email'],
            campaign_id="high-intent-vp",
            personalization={
                'company': enriched['company'],
                'trigger': enriched['page_visited']
            }
        )

Deal Resurrector

from deal_resurrector import DealResurrector

resurrector = DealResurrector(
    crm_api_key=os.getenv("SALESFORCE_API_KEY")
)

# Find stale deals with departed champions
stale_deals = resurrector.find_stale_deals(
    days_inactive=90,
    min_deal_value=10000
)

# Track champions to new companies
for deal in stale_deals:
    champion_moves = resurrector.track_champion(
        champion_email=deal['primary_contact'],
        linkedin_api_key=os.getenv("LINKEDIN_API_KEY")
    )
    
    if champion_moves['new_company']:
        resurrector.create_new_opportunity(
            company=champion_moves['new_company'],
            contact=champion_moves['new_email'],
            context=deal['previous_context']
        )

ICP Learner

from icp_learning_analyzer import ICPLearner

learner = ICPLearner()

# Analyze win/loss patterns
deals = learner.fetch_closed_deals(months_back=12)
patterns = learner.analyze_patterns(deals)

# Update ICP definition
new_icp = learner.update_icp(
    current_icp="""
    Company size: 50-500 employees
    Industry: SaaS, E-commerce
    Tech stack: React, Python
    """,
    win_loss_data=patterns
)

print(new_icp)

Content Ops

Ship content that scores 90+ every time.

Expert Panel

from expert_panel import ExpertPanel

panel = ExpertPanel(
    api_key=os.getenv("ANTHROPIC_API_KEY")
)

# Load expert personas
panel.load_experts([
    'experts/seo_expert.json',
    'experts/conversion_expert.json',
    'experts/content_strategist.json'
])

# Score content
content = """
Your blog post content here...
"""

scores = panel.score_content(
    content=content,
    rubric='scoring-rubrics/blog_post.json',
    min_score=90
)

# Recursive improvement
while scores['average'] < 90:
    feedback = panel.get_improvement_suggestions(scores)
    content = panel.improve_content(content, feedback)
    scores = panel.score_content(content, 'scoring-rubrics/blog_post.json')

print(f"Final score: {scores['average']}")
print(f"Expert breakdown: {scores['by_expert']}")

Quality Gate

# CLI quality gate
python quality-gate.py check \
  --file blog-post.md \
  --rubric scoring-rubrics/blog_post.json \
  --min-score 90 \
  --experts seo conversion content-strategy

Outbound Engine

ICP to inbox automation.

Cold Outbound Optimizer

from cold_outbound_optimizer import OutboundEngine

engine = OutboundEngine(
    apollo_key=os.getenv("APOLLO_API_KEY"),
    instantly_key=os.getenv("INSTANTLY_API_KEY")
)

# Define ICP
icp = {
    'titles': ['VP Marketing', 'CMO', 'Head of Growth'],
    'company_size': [50, 500],
    'industries': ['SaaS', 'E-commerce'],
    'technologies': ['HubSpot', 'Salesforce']
}

# Build lead list
leads = engine.build_lead_list(
    icp=icp,
    limit=1000,
    exclude_domains=['competitor1.com', 'competitor2.com']
)

# Generate personalized emails
for lead in leads:
    email = engine.generate_email(
        lead=lead,
        template='references/cold_email_template.md',
        personalization_depth='high'
    )
    
    engine.add_to_sequence(
        email=lead['email'],
        campaign='q2-outbound',
        message=email
    )

SEO Ops

Find keywords your competitors missed.

Content Attack Brief

from content_attack_brief import SEOBrief

brief = SEOBrief(
    gsc_credentials=os.getenv("GOOGLE_SEARCH_CONSOLE_CREDENTIALS")
)

# Analyze content gaps
gaps = brief.find_content_gaps(
    target_domain='yoursite.com',
    competitor_domains=['competitor1.com', 'competitor2.com'],
    topic='marketing automation'
)

# Generate brief
content_brief = brief.generate_brief(
    keyword=gaps[0]['keyword'],
    search_intent=gaps[0]['intent'],
    top_ranking_urls=gaps[0]['serp_results']
)

print(content_brief)

GSC Optimizer

# CLI GSC optimization
python gsc_client.py analyze \
  --domain yoursite.com \
  --lookback-days 90 \
  --min-impressions 1000 \
  --position-range 11-20

Finance Ops

AI CFO for cost analysis.

CFO Briefing

from cfo_briefing import FinanceAnalyzer

analyzer = FinanceAnalyzer()

# Upload financial data
analyzer.load_data(
    expenses='data/expenses_q1.csv',
    revenue='data/revenue_q1.csv'
)

# Generate CFO briefing
briefing = analyzer.generate_briefing(
    focus_areas=['hidden_costs', 'vendor_optimization', 'budget_variance']
)

# Get cost-saving recommendations
recommendations = analyzer.find_savings_opportunities(
    min_impact=5000  # Minimum $5k annual savings
)

print(briefing)
for rec in recommendations:
    print(f"{rec['category']}: Save ${rec['annual_savings']:,.0f}")

Revenue Intelligence

Sales call insights and attribution.

Gong Insight Pipeline

from gong_insight_pipeline import GongAnalyzer

analyzer = GongAnalyzer(
    gong_api_key=os.getenv("GONG_API_KEY")
)

# Fetch recent calls
calls = analyzer.fetch_calls(
    date_range='last_7_days',
    min_duration_minutes=20
)

# Extract insights
for call in calls:
    insights = analyzer.extract_insights(call['id'])
    
    # Key patterns
    print(f"Objections: {insights['objections']}")
    print(f"Competitor mentions: {insights['competitors']}")
    print(f"Next steps: {insights['next_steps']}")
    
    # Update CRM
    analyzer.sync_to_crm(
        call_id=call['id'],
        insights=insights,
        crm='salesforce'
    )

Troubleshooting

API Rate Limits

# All scripts include retry logic with exponential backoff
from utils import retry_with_backoff

@retry_with_backoff(max_retries=5, base_delay=2)
def api_call():
    return client.make_request()

PII Sanitization

# Scan for sensitive data before commits
python3 security/sanitizer.py --scan --dir . --recursive

# Install pre-commit hook
cp security/pre-commit-hook.sh .git/hooks/pre-commit
chmod +x .git/hooks/pre-commit

Dependencies Issues

# Each category has isolated dependencies
cd growth-engine
pip install --upgrade -r requirements.txt

# If conflicts, use virtual environment
python -m venv venv
source venv/bin/activate  # or venv\Scripts\activate on Windows
pip install -r requirements.txt

Data Privacy

All scripts sanitize PII by default:

from security.sanitizer import sanitize_output

# Automatically removes emails, phone numbers, API keys
safe_data = sanitize_output(raw_data)

Common Patterns

Chain Multiple Skills

# Example: SEO → Content → Quality Gate → Publish
from content_attack_brief import SEOBrief
from expert_panel import ExpertPanel

# 1. Get SEO brief
brief = SEOBrief().generate_brief(keyword='ai marketing automation')

# 2. Generate content
content = generate_from_brief(brief)  # Your content generation

# 3. Score with expert panel
panel = ExpertPanel()
scores = panel.score_content(content, min_score=90)

# 4. Publish if passed
if scores['average'] >= 90:
    publish_to_cms(content)

Telemetry (Opt-In)

# View local usage stats
python3 telemetry/telemetry_report.py

# Check for updates
python3 telemetry/version_check.py

# Opt out of remote telemetry (local logging still works)
export AI_MARKETING_SKILLS_TELEMETRY=false

Project Structure

ai-marketing-skills/
├── growth-engine/          # Experiments, pacing, scorecards
├── sales-pipeline/         # RB2B, deal resurrector, ICP learner
├── content-ops/            # Expert panel, quality gates
├── outbound-engine/        # Cold email automation
├── seo-ops/                # Content gaps, GSC analysis
├── finance-ops/            # CFO briefings, cost analysis
├── revenue-intelligence/   # Gong insights, attribution
├── conversion-ops/         # CRO audits, lead magnets
├── podcast-ops/            # Episode → content pipeline
├── sales-playbook/         # Value pricing frameworks
├── autoresearch/           # Evolutionary content optimization
├── deck-generator/         # AI slide decks
├── yt-competitive-analysis/ # YouTube outlier detection
└── x-longform-post/        # Human-sounding X posts

Each category contains:

SKILL.md — Category-specific skill documentation
scripts/ — Python automation scripts
requirements.txt — Dependencies
.env.example — Configuration template
README.md — Category guide

ai-marketing-skills-automation

About