# Install all skills
npx skills coreyhaines31/marketingskills

# Install specific skills
npx skills coreyhaines31/marketingskills --skills seo-audit,copywriting,cro

# Install to custom directory
npx skills coreyhaines31/marketingskills --dir .ai/custom-skills

# Clone the repository
git clone https://github.com/coreyhaines31/marketingskills.git

# Copy skills to your project's .ai directory
cp -r marketingskills/skills .ai/

# Add as submodule
git submodule add https://github.com/coreyhaines31/marketingskills.git .ai/marketingskills

# Update submodule
git submodule update --remote .ai/marketingskills

marketingskills/
├── skills/                    # All skill markdown files
│   ├── product-marketing/     # Foundation skill (read by all others)
│   │   └── SKILL.md
│   ├── seo-audit/
│   │   └── SKILL.md
│   ├── copywriting/
│   │   └── SKILL.md
│   ├── cro/
│   │   └── SKILL.md
│   └── [40+ more skills]/
├── examples/                  # Example outputs and workflows
├── scripts/                   # Utility scripts
└── README.md

---
name: skill-name-kebab-case
description: One-line description of what the skill does
triggers:
  - "when user says this"
  - "or mentions this"
---

## Related Skills

- **product-marketing** — Always read first to understand product context
- **customer-research** — Use to gather insights before writing copy
- **ab-testing** — Use to test copy variations

// Agent automatically uses product-marketing skill when you say:
// "Create a product marketing context document for my SaaS"

// The skill will prompt for:
// - Product name and tagline
// - Target audience and personas
// - Core value propositions
// - Key features and benefits
// - Competitors and differentiation
// - Brand voice and tone

// Output saved to: product-context.md or .ai/product-marketing.md

// Agent uses seo-audit skill when you say:
// "Audit my website's SEO"

// The skill will:
// 1. Check product-marketing context first
// 2. Analyze site structure and technical SEO
// 3. Review on-page optimization
// 4. Check content quality and targeting
// 5. Provide prioritized recommendations

// Example output structure:
const seoAuditReport = {
  technical: {
    siteSpeed: "analysis",
    mobileFriendly: "check",
    indexability: "status",
    structuredData: "validation"
  },
  onPage: {
    titleTags: "optimization",
    metaDescriptions: "review",
    headings: "hierarchy",
    internalLinking: "analysis"
  },
  content: {
    keywordTargeting: "gaps",
    contentQuality: "assessment",
    topicalAuthority: "score"
  },
  recommendations: [
    { priority: "high", task: "Fix crawl errors", impact: "Critical" },
    { priority: "medium", task: "Improve title tags", impact: "High" }
  ]
};

// Agent uses cro skill when you say:
// "Help me improve conversions on my landing page"

// The skill applies CRO frameworks:
// 1. Reads product-marketing context
// 2. Analyzes current page structure
// 3. Applies conversion optimization principles
// 4. Suggests A/B test ideas

// Example CRO analysis
const croRecommendations = {
  headline: {
    current: "We help businesses grow",
    suggested: "Double your leads in 30 days",
    reasoning: "Specific outcome + timeframe"
  },
  cta: {
    current: "Sign up",
    suggested: "Start your free trial",
    reasoning: "Lower friction, clear value"
  },
  socialProof: {
    add: ["customer logos", "testimonials", "case study metrics"],
    placement: "above the fold"
  },
  experiments: [
    { test: "Hero headline variations", priority: "high" },
    { test: "CTA button copy", priority: "high" },
    { test: "Pricing display", priority: "medium" }
  ]
};

// Agent uses copywriting skill when you say:
// "Write homepage copy for my product"

// The skill follows this workflow:
// 1. Read product-marketing context
// 2. Apply copywriting frameworks (AIDA, PAS, etc.)
// 3. Generate copy variations
// 4. Suggest improvements

// Example generated copy structure
const homepageCopy = {
  hero: {
    headline: "Turn Visitors Into Customers",
    subheadline: "AI-powered conversion optimization for modern SaaS",
    cta: "Start optimizing free"
  },
  valueProps: [
    {
      headline: "Know exactly what to test",
      body: "AI analyzes your traffic and suggests high-impact experiments"
    },
    {
      headline: "Ship tests in minutes, not days",
      body: "Visual editor makes A/B testing accessible to any team"
    }
  ],
  socialProof: {
    stat: "10,000+ companies trust us",
    testimonial: "We increased signups 47% in the first month"
  }
};

// Agent uses analytics skill when you say:
// "Set up Google Analytics 4 tracking"

// The skill provides implementation code
// Example: GA4 setup with custom events

// Install gtag
const setupGA4 = () => {
  // Add to <head>
  const gtagScript = `
    <script async src="https://www.googletagmanager.com/gtag/js?id=${process.env.GA4_MEASUREMENT_ID}"></script>
    <script>
      window.dataLayer = window.dataLayer || [];
      function gtag(){dataLayer.push(arguments);}
      gtag('js', new Date());
      gtag('config', '${process.env.GA4_MEASUREMENT_ID}');
    </script>
  `;
};

// Track custom events
const trackConversion = (eventName, value) => {
  if (typeof gtag !== 'undefined') {
    gtag('event', eventName, {
      'event_category': 'conversion',
      'event_label': eventName,
      'value': value
    });
  }
};

// Example usage
trackConversion('trial_started', 1);
trackConversion('purchase_completed', 99);

// Agent uses programmatic-seo skill when you say:
// "Create landing pages for all my competitors"

// Example: Generate competitor comparison pages
const generateCompetitorPages = async (competitors) => {
  // Read product context
  const product = await readProductContext();
  
  // Template for competitor pages
  const template = (competitor) => ({
    url: `/vs/${competitor.slug}`,
    title: `${product.name} vs ${competitor.name} - Comparison`,
    metaDescription: `Compare ${product.name} and ${competitor.name}. See features, pricing, and why teams choose ${product.name}.`,
    schema: {
      "@type": "ComparisonTable",
      items: [product, competitor]
    },
    sections: {
      hero: `${product.name} vs ${competitor.name}`,
      comparison: generateComparisonTable(product, competitor),
      whyChooseUs: generateDifferentiators(product, competitor),
      cta: `Try ${product.name} free`
    }
  });
  
  // Generate pages
  return competitors.map(competitor => ({
    path: `/vs/${competitor.slug}/index.html`,
    content: renderTemplate(template(competitor))
  }));
};

// Agent uses emails skill when you say:
// "Create an onboarding email sequence"

// Example: Trial onboarding sequence
const onboardingSequence = [
  {
    delay: 0,
    subject: "Welcome to {product_name}! Here's what to do first",
    preview: "Get started in 3 simple steps",
    body: `
      Hi {first_name},
      
      Welcome! Here's how to get the most value in your first week:
      
      1. Complete your profile (2 min)
      2. Import your data (5 min)
      3. Run your first campaign (10 min)
      
      [Get Started] → {onboarding_url}
    `
  },
  {
    delay: 2, // days
    subject: "Quick question about your {product_name} trial",
    condition: "not_activated",
    body: `
      Hi {first_name},
      
      I noticed you haven't {activation_milestone} yet.
      
      Is there anything blocking you? Hit reply and I'll personally help.
      
      Common issues we've solved:
      - Integration setup
      - Data import
      - Team training
      
      Want to jump on a quick call? [Book 15 min]
    `
  },
  {
    delay: 5,
    subject: "Your trial ends in 2 days",
    condition: "trial_ending",
    body: `
      Hi {first_name},
      
      Your trial ends in 2 days. Here's what you've achieved:
      
      ✓ {metric_1}
      ✓ {metric_2}
      ✓ {metric_3}
      
      Ready to keep going? [Choose your plan]
      
      Questions? Reply to this email.
    `
  }
];

// Implementation with variables
const sendEmail = (template, user) => {
  const variables = {
    product_name: process.env.PRODUCT_NAME,
    first_name: user.firstName,
    onboarding_url: `${process.env.APP_URL}/onboarding`,
    activation_milestone: "imported your first campaign",
    metric_1: user.metrics.campaigns,
    metric_2: user.metrics.conversions,
    metric_3: user.metrics.revenue
  };
  
  return replaceVariables(template.body, variables);
};

// Agent uses ab-testing skill when you say:
// "Set up an A/B test for my pricing page"

// Example: Client-side A/B test implementation
const abTest = {
  name: "pricing_page_layout",
  variants: {
    control: { 
      layout: "traditional",
      weight: 0.5 
    },
    treatment: { 
      layout: "comparison_table",
      weight: 0.5 
    }
  },
  metrics: {
    primary: "trial_signups",
    secondary: ["page_views", "time_on_page", "scroll_depth"]
  }
};

// Assignment function
const assignVariant = (userId, testName) => {
  const hash = simpleHash(`${userId}-${testName}`);
  return hash % 100 < 50 ? 'control' : 'treatment';
};

// Track experiment exposure
const trackExperiment = (testName, variant) => {
  if (typeof gtag !== 'undefined') {
    gtag('event', 'experiment_view', {
      'experiment_name': testName,
      'variant': variant
    });
  }
};

// Track conversion
const trackConversion = (testName, variant, metric) => {
  if (typeof gtag !== 'undefined') {
    gtag('event', metric, {
      'experiment_name': testName,
      'variant': variant
    });
  }
};

// Usage
const variant = assignVariant(user.id, 'pricing_page_layout');
trackExperiment('pricing_page_layout', variant);

// On conversion
document.querySelector('.signup-button').addEventListener('click', () => {
  trackConversion('pricing_page_layout', variant, 'trial_signups');
});

# Product context
PRODUCT_NAME="Your Product"
PRODUCT_URL="https://yourproduct.com"

# Analytics
GA4_MEASUREMENT_ID="G-XXXXXXXXXX"
GOOGLE_TAG_MANAGER_ID="GTM-XXXXXX"

# Marketing platforms
MAILCHIMP_API_KEY="your_api_key"
HUBSPOT_API_KEY="your_api_key"

# SEO tools
AHREFS_API_KEY="your_api_key"
SEMRUSH_API_KEY="your_api_key"

// Default: .ai/skills/
// Custom: .ai/custom-skills/
// Or any directory your agent checks

// Specify in your agent config
{
  "skillsDirectory": ".ai/marketingskills/skills"
}

// Pattern: Research → Strategy → Execution → Optimization
// 1. customer-research - gather insights
// 2. product-marketing - define positioning
// 3. copywriting - write messaging
// 4. cro - optimize conversion
// 5. ab-testing - validate improvements

// When writing copy, agent might also use:
// - customer-research (for voice of customer)
// - marketing-psychology (for persuasion principles)
// - ab-testing (for testing variations)
// - copy-editing (for refinement)

// Pattern: Audit → Analyze → Recommend → Implement
// Example: SEO workflow

// 1. seo-audit - identify issues
const auditResults = await runSEOAudit(siteUrl);

// 2. Analyze findings
const prioritized = prioritizeIssues(auditResults);

// 3. ai-seo - optimize for AI search
const aiOptimizations = generateAISearchContent();

// 4. schema - add structured data
const schemaMarkup = generateSchemaMarkup();

// 5. analytics - track improvements
const tracking = setupSEOTracking();

# Verify skills directory exists
ls -la .ai/skills/

# Check skill file structure
cat .ai/skills/product-marketing/SKILL.md

# Ensure YAML frontmatter is valid
# Skills must start with ---

# Be explicit in your prompts
# Instead of: "help with marketing"
# Try: "use the seo-audit skill to analyze my site"

# Or: "read my product-marketing context and write homepage copy"

# Most skills require product-marketing context first
# Create it with:
# "Create a product marketing context document"

# Or manually create:
# .ai/product-marketing.md

# If multiple skills trigger, be specific:
# "use the copywriting skill" (not just "write copy")
# "use the cold-email skill" (not just "write email")

// pages/vs/[competitor].js
import { generateCompetitorPage } from '@/lib/programmatic-seo';
import { getProductContext } from '@/lib/product-marketing';

export async function getStaticPaths() {
  const competitors = await getCompetitors();
  return {
    paths: competitors.map(c => ({ params: { competitor: c.slug } })),
    fallback: false
  };
}

export async function getStaticProps({ params }) {
  const product = await getProductContext();
  const competitor = await getCompetitor(params.competitor);
  const page = await generateCompetitorPage(product, competitor);
  
  return { props: { page } };
}

// components/ABTest.jsx
import { useEffect, useState } from 'react';
import { assignVariant, trackExperiment } from '@/lib/ab-testing';

export const ABTest = ({ testName, variants, children }) => {
  const [variant, setVariant] = useState(null);
  
  useEffect(() => {
    const userId = getUserId();
    const assigned = assignVariant(userId, testName);
    setVariant(assigned);
    trackExperiment(testName, assigned);
  }, [testName]);
  
  if (!variant) return null;
  
  return children(variants[variant]);
};

// Usage
<ABTest 
  testName="hero_headline"
  variants={{
    control: { headline: "Welcome" },
    treatment: { headline: "Double Your Growth" }
  }}
>
  {(variant) => <h1>{variant.headline}</h1>}
</ABTest>

// server.js
import express from 'express';
import { trackEvent } from './lib/analytics.js';

const app = express();

app.post('/api/track', async (req, res) => {
  const { event, properties } = req.body;
  
  await trackEvent(event, {
    ...properties,
    timestamp: new Date(),
    userAgent: req.headers['user-agent'],
    ip: req.ip
  });
  
  res.json({ success: true });
});

app.listen(3000);

# Fork the repository
git clone https://github.com/YOUR_USERNAME/marketingskills.git

# Create a new skill
mkdir skills/your-skill-name
cd skills/your-skill-name

# Create SKILL.md with frontmatter
cat > SKILL.md << 'EOF'
---
name: your-skill-name
description: One-line description
triggers:
  - "trigger phrase 1"
  - "trigger phrase 2"
---

# Your Skill Name

Content here...
EOF

# Submit PR
git add skills/your-skill-name/
git commit -m "Add your-skill-name skill"
git push origin main