vibebusiness 1.2.87 → 1.2.89

package/scripts/lib/video/compositions/DemoVideo.tsx

@@ -12,7 +12,7 @@
  */
 
 import React from 'react';
-import { AbsoluteFill, Sequence, useCurrentFrame, interpolate, spring } from 'remotion';
+import { AbsoluteFill, Sequence, useCurrentFrame, interpolate } from 'remotion';
 import { BackgroundMusic } from './BackgroundMusic';
 import type { AudioConfig } from '../renderer';
 
@@ -33,7 +33,6 @@ export interface DemoSlideData {
 export interface DemoVideoProps {
   slides: DemoSlideData[];
   format: 'feed' | 'reels';
-  variant?: 'fast' | 'dynamic';
   audio?: AudioConfig;
 }
 
@@ -44,56 +43,22 @@ const TEXT = '#ffffff';
 const MUTED = 'rgba(255,255,255,0.6)';
 const FONT = '"Inter", -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
 
-// Variant-specific frame durations
-const FRAME_DURATIONS: Record<string, Record<string, number>> = {
-  fast: {
-    cover: 60,        // 2s
-    terminal: 90,     // 3s
-    key_point: 60,    // 2s
-    notification: 60, // 2s
-    steps: 90,        // 3s (kanban)
-    kanban: 90,       // 3s
-    pipeline: 90,     // 3s
-    quote: 90,        // 3s
-    cta: 75,          // 2.5s
-  },
-  dynamic: {
-    cover: 75,        // 2.5s
-    terminal: 105,    // 3.5s
-    key_point: 75,    // 2.5s
-    notification: 75, // 2.5s
-    steps: 105,       // 3.5s (kanban)
-    kanban: 105,      // 3.5s
-    pipeline: 105,    // 3.5s
-    quote: 105,       // 3.5s
-    cta: 90,          // 3s
-  },
-};
-
-// Variant-specific animation configuration
-const ANIMATION_CONFIG = {
-  fast: {
-    transitionFrames: 8,
-    charsPerFrame: 4,
-    kanbanDelay: 5,
-    enableBounce: false,
-    enableSpring: false,
-    enableGlow: false,
-  },
-  dynamic: {
-    transitionFrames: 12,
-    charsPerFrame: 3,
-    kanbanDelay: 7,
-    enableBounce: true,
-    enableSpring: true,
-    enableGlow: true,
-  },
+// Custom frame durations for different scene types
+const FRAME_DURATIONS: Record<string, number> = {
+  cover: 90,        // 3s
+  terminal: 150,    // 5s
+  key_point: 90,    // 3s
+  notification: 90, // 3s
+  steps: 150,       // 5s (kanban)
+  kanban: 150,      // 5s
+  pipeline: 135,    // 4.5s
+  quote: 135,       // 4.5s
+  cta: 105,         // 3.5s
 };
 
 // ─── DemoVideo ──────────────────────────────────────────────────────────────
 
-export const DemoVideo: React.FC<DemoVideoProps> = ({ slides, audio, variant = 'dynamic' }) => {
-  const durations = FRAME_DURATIONS[variant];
+export const DemoVideo: React.FC<DemoVideoProps> = ({ slides, audio }) => {
   let currentFrame = 0;
 
   return (
@@ -103,13 +68,13 @@ export const DemoVideo: React.FC<DemoVideoProps> = ({ slides, audio, variant = '
       }}
     >
       {slides.map((slide, i) => {
-        const duration = durations[slide.type] || 90;
+        const duration = FRAME_DURATIONS[slide.type] || 90;
         const from = currentFrame;
         currentFrame += duration;
 
         return (
           <Sequence key={i} from={from} durationInFrames={duration}>
-            <DemoSlide slide={slide} variant={variant} />
+            <DemoSlide slide={slide} />
           </Sequence>
         );
       })}
@@ -120,30 +85,10 @@ export const DemoVideo: React.FC<DemoVideoProps> = ({ slides, audio, variant = '
 
 // ─── DemoSlide ──────────────────────────────────────────────────────────────
 
-const DemoSlide: React.FC<{ slide: DemoSlideData; variant: string }> = ({ slide, variant }) => {
-  const config = ANIMATION_CONFIG[variant as keyof typeof ANIMATION_CONFIG];
+const DemoSlide: React.FC<{ slide: DemoSlideData }> = ({ slide }) => {
   const frame = useCurrentFrame();
-
-  // Entrance animation with optional bounce
-  const opacity = interpolate(frame, [0, config.transitionFrames], [0, 1], { extrapolateRight: 'clamp' });
-
-  let y = interpolate(frame, [0, config.transitionFrames], [24, 0], { extrapolateRight: 'clamp' });
-
-  if (config.enableBounce && frame > config.transitionFrames) {
-    const overshoot = interpolate(
-      frame,
-      [config.transitionFrames, config.transitionFrames + 8],
-      [0, -4],
-      { extrapolateRight: 'clamp' }
-    );
-    const settle = interpolate(
-      frame,
-      [config.transitionFrames + 8, config.transitionFrames + 16],
-      [-4, 0],
-      { extrapolateRight: 'clamp' }
-    );
-    y = frame <= config.transitionFrames + 8 ? overshoot : settle;
-  }
+  const opacity = interpolate(frame, [0, 15], [0, 1], { extrapolateRight: 'clamp' });
+  const y = interpolate(frame, [0, 15], [24, 0], { extrapolateRight: 'clamp' });
 
   return (
     <AbsoluteFill
@@ -159,14 +104,14 @@ const DemoSlide: React.FC<{ slide: DemoSlideData; variant: string }> = ({ slide,
         alignItems: 'flex-start',
       }}
     >
-      <SlideContent slide={slide} variant={variant} />
+      <SlideContent slide={slide} />
     </AbsoluteFill>
   );
 };
 
 // ─── Slide content by type ──────────────────────────────────────────────────
 
-function SlideContent({ slide, variant }: { slide: DemoSlideData; variant: string }) {
+function SlideContent({ slide }: { slide: DemoSlideData }) {
   const frame = useCurrentFrame();
 
   switch (slide.type) {
@@ -194,7 +139,7 @@ function SlideContent({ slide, variant }: { slide: DemoSlideData; variant: strin
       );
 
     case 'terminal':
-      return <TerminalScene title={slide.title} content={slide.content || ''} frame={frame} variant={variant} />;
+      return <TerminalScene title={slide.title} content={slide.content || ''} frame={frame} />;
 
     case 'notification':
       return <NotificationScene title={slide.title} content={slide.content || ''} frame={frame} />;
@@ -222,10 +167,10 @@ function SlideContent({ slide, variant }: { slide: DemoSlideData; variant: strin
 
     case 'steps':
     case 'kanban':
-      return <KanbanScene title={slide.title} items={slide.items || []} frame={frame} variant={variant} />;
+      return <KanbanScene title={slide.title} items={slide.items || []} frame={frame} />;
 
     case 'pipeline':
-      return <PipelineScene title={slide.title} content={slide.content || ''} label={slide.label} frame={frame} variant={variant} />;
+      return <PipelineScene title={slide.title} content={slide.content || ''} label={slide.label} frame={frame} />;
 
     case 'quote':
       return (
@@ -293,11 +238,10 @@ function SlideContent({ slide, variant }: { slide: DemoSlideData; variant: strin
 
 // ─── Custom Scene Components ────────────────────────────────────────────────
 
-function TerminalScene({ title, content, frame, variant }: { title: string; content: string; frame: number; variant: string }) {
+function TerminalScene({ title, content, frame }: { title: string; content: string; frame: number }) {
   // Typewriter effect
-  const config = ANIMATION_CONFIG[variant as keyof typeof ANIMATION_CONFIG];
   const lines = content.split('\n');
-  const charsPerFrame = config.charsPerFrame;
+  const charsPerFrame = 2;
   const visibleChars = Math.floor(frame * charsPerFrame);
 
   let charCount = 0;
@@ -378,9 +322,7 @@ function NotificationScene({ title, content, frame }: { title: string; content:
   );
 }
 
-function KanbanScene({ title, items, frame, variant }: { title: string; items: string[]; frame: number; variant: string }) {
-  const config = ANIMATION_CONFIG[variant as keyof typeof ANIMATION_CONFIG];
-
+function KanbanScene({ title, items, frame }: { title: string; items: string[]; frame: number }) {
   return (
     <div style={{ width: '100%' }}>
       <div
@@ -397,19 +339,9 @@ function KanbanScene({ title, items, frame, variant }: { title: string; items: s
       </div>
       <div style={{ display: 'flex', gap: 24 }}>
         {items.map((item, i) => {
-          const delay = i * config.kanbanDelay;
-
-          let opacity, scale;
-
-          if (config.enableSpring) {
-            // Use spring physics
-            opacity = spring({ frame: frame - delay, fps: 30, config: { damping: 15, mass: 0.5 } });
-            scale = spring({ frame: frame - delay, fps: 30, config: { damping: 12, mass: 0.6 } }) * 0.2 + 0.8;
-          } else {
-            // Use linear interpolation
-            opacity = interpolate(frame, [delay, delay + 15], [0, 1], { extrapolateRight: 'clamp' });
-            scale = interpolate(frame, [delay, delay + 15], [0.8, 1], { extrapolateRight: 'clamp' });
-          }
+          const delay = i * 10;
+          const opacity = interpolate(frame, [delay, delay + 15], [0, 1], { extrapolateRight: 'clamp' });
+          const scale = interpolate(frame, [delay, delay + 15], [0.8, 1], { extrapolateRight: 'clamp' });
 
           return (
             <div
@@ -436,8 +368,7 @@ function KanbanScene({ title, items, frame, variant }: { title: string; items: s
   );
 }
 
-function PipelineScene({ title, content, label, frame, variant }: { title: string; content: string; label?: string; frame: number; variant: string }) {
-  const config = ANIMATION_CONFIG[variant as keyof typeof ANIMATION_CONFIG];
+function PipelineScene({ title, content, label, frame }: { title: string; content: string; label?: string; frame: number }) {
   const steps = content.split(' → ');
   const progress = interpolate(frame, [0, 100], [0, 1], { extrapolateRight: 'clamp' });
 
@@ -456,41 +387,26 @@ function PipelineScene({ title, content, label, frame, variant }: { title: strin
         {title}
       </div>
       <div style={{ display: 'flex', alignItems: 'center', gap: 16, marginBottom: 32 }}>
-        {steps.map((step, i) => {
-          const isActive = i / (steps.length - 1) <= progress;
-
-          let boxShadow = 'none';
-          if (config.enableGlow && isActive) {
-            const glowIntensity = interpolate(
-              frame % 30,
-              [0, 15, 30],
-              [0.3, 0.6, 0.3],
-              { extrapolateRight: 'clamp' }
-            );
-            boxShadow = `0 0 ${20 * glowIntensity}px rgba(16, 185, 129, ${glowIntensity})`;
-          }
-
-          return (
-            <React.Fragment key={i}>
-              <div
-                style={{
-                  padding: '16px 24px',
-                  background: isActive ? ACCENT : 'rgba(255,255,255,0.1)',
-                  borderRadius: 8,
-                  fontSize: 20,
-                  fontWeight: 600,
-                  color: isActive ? '#0f172a' : TEXT,
-                  boxShadow,
-                }}
-              >
-                {step}
-              </div>
-              {i < steps.length - 1 && (
-                <div style={{ fontSize: 24, color: MUTED }}>→</div>
-              )}
-            </React.Fragment>
-          );
-        })}
+        {steps.map((step, i) => (
+          <React.Fragment key={i}>
+            <div
+              style={{
+                padding: '16px 24px',
+                background: i / (steps.length - 1) <= progress ? ACCENT : 'rgba(255,255,255,0.1)',
+                borderRadius: 8,
+                fontSize: 20,
+                fontWeight: 600,
+                color: i / (steps.length - 1) <= progress ? '#0f172a' : TEXT,
+                transition: 'all 0.3s',
+              }}
+            >
+              {step}
+            </div>
+            {i < steps.length - 1 && (
+              <div style={{ fontSize: 24, color: MUTED }}>→</div>
+            )}
+          </React.Fragment>
+        ))}
       </div>
       {label && (
         <div

package/scripts/lib/video/compositions/Root.tsx

@@ -111,30 +111,11 @@ export const RemotionRoot: React.FC = () => {
       <Composition
         id="DemoFeed"
         component={DemoComp}
-        durationInFrames={630} // Default to dynamic variant duration
+        durationInFrames={810} // 27 seconds at 30fps
         fps={30}
         width={1080}
         height={1080}
-        defaultProps={{ slides: defaultDemoSlides, format: 'feed', variant: 'dynamic' } as DemoVideoProps}
-        calculateMetadata={({ props }) => {
-          const p = props as unknown as DemoVideoProps;
-          const variant = p.variant || 'dynamic';
-
-          // Calculate total duration based on variant and slides
-          const durations = variant === 'fast'
-            ? { cover: 60, terminal: 90, key_point: 60, notification: 60, steps: 90, kanban: 90, pipeline: 90, quote: 90, cta: 75 }
-            : { cover: 75, terminal: 105, key_point: 75, notification: 75, steps: 105, kanban: 105, pipeline: 105, quote: 105, cta: 90 };
-
-          let totalFrames = 0;
-          p.slides.forEach(slide => {
-            totalFrames += durations[slide.type as keyof typeof durations] || 90;
-          });
-
-          return {
-            durationInFrames: totalFrames,
-            props,
-          };
-        }}
+        defaultProps={{ slides: defaultDemoSlides, format: 'feed' } as DemoVideoProps}
       />
     </>
   );

package/templates/commands/distribution-google-ads.md

@@ -0,0 +1,86 @@
+# /distribution-google-ads — Google Ads Campaign Playbook
+
+## Usage
+```
+/distribution-google-ads              # Full campaign design
+/distribution-google-ads {keyword}    # Campaign for specific keyword cluster
+```
+
+## Input
+- `$ARGUMENTS` — optional: specific keyword or keyword cluster to target
+
+## Process
+
+### Step 1: Load Context
+1. Read `data/positioning.json` — value proposition, target audience, differentiators
+2. Read `data/competitors.json` — competitor SEO keywords, growth channels
+3. Read `data/business-context.json` — product name, funnels, KPIs, monetization
+
+### Step 2: Keyword Research
+Use WebSearch to find keyword opportunities:
+- `"[product category] google ads keywords [year]"`
+- `"[product category] search volume CPC benchmarks"`
+- `"[competitor name] google ads keywords"` (for each top competitor)
+- `"[product pain point] solution"` (problem-aware searches)
+
+For each keyword group, estimate:
+- Monthly search volume
+- Average CPC
+- Competition level (low/medium/high)
+- Commercial intent (informational/commercial/transactional)
+
+### Step 3: Campaign Structure
+Design campaigns following Google Ads best practices:
+
+```
+Campaign: [Product Category] — Search
+├── Ad Group: Brand Terms
+│   ├── Keywords: [product name], [product name] review, [product name] pricing
+│   └── Negative: free, open source, tutorial
+├── Ad Group: Problem-Aware
+│   ├── Keywords: [pain point] solution, how to [solve problem]
+│   └── Negative: DIY, manual
+├── Ad Group: Competitor Terms
+│   ├── Keywords: [competitor] alternative, [competitor] vs
+│   └── Negative: [competitor] login, [competitor] support
+└── Ad Group: Category Terms
+    ├── Keywords: best [category] tool, [category] software
+    └── Negative: free, open source
+```
+
+### Step 4: Generate Ad Copy
+For each ad group, queue copy generation:
+- `/promo-copy ad-google {keyword}` — generates 3 headlines (30 chars) + 2 descriptions (90 chars)
+- Ensure copy matches keyword intent
+- Include call-to-action aligned with landing page
+
+### Step 5: Landing Page Recommendations
+For each ad group:
+- Map to existing page if available (check `data/pages.json`)
+- If no matching page exists, queue `/build-page {slug}` with ad-specific messaging
+- Ensure landing page has conversion tracking (PostHog events)
+
+### Step 6: Budget & Bidding Strategy
+Recommend starting budget:
+- **Phase 1 (Week 1-2):** $10-15/day across all ad groups — gather data
+- **Phase 2 (Week 3-4):** Pause underperformers, double down on winners — $15-20/day
+- **Bidding:** Start with Maximize Clicks, switch to Target CPA after 30 conversions
+
+### Step 7: Conversion Tracking
+Define tracking setup:
+- UTM parameters: `utm_source=google&utm_medium=cpc&utm_campaign={campaign-slug}&utm_content={ad-group}`
+- PostHog events to track: page_view, signup_started, signup_completed
+- Google Ads conversion action: signup_completed
+
+### Step 8: Output
+For each campaign, create an idea in `data/ideas.json` with:
+- Category: "growth"
+- Tags: ["growth", "google-ads", "{keyword-group}"]
+- Implementation plan with full campaign structure
+- Success metrics: impressions, clicks, CTR, CPC, conversions, CPA
+- Budget recommendation
+- Queue `copy-ad-google-{keyword}` tasks
+
+## Output Files
+- `data/ideas.json` — new Google Ads campaign ideas
+- `data/campaigns/` — campaign briefs (optional)

package/templates/commands/distribution-meta-ads.md

@@ -0,0 +1,106 @@
+# /distribution-meta-ads — Meta/Instagram Ads Campaign Playbook
+
+## Usage
+```
+/distribution-meta-ads                # Full campaign design
+/distribution-meta-ads {audience}     # Campaign for specific audience segment
+```
+
+## Input
+- `$ARGUMENTS` — optional: specific audience segment to target
+
+## Process
+
+### Step 1: Load Context
+1. Read `data/positioning.json` — value proposition, target audience, pain points
+2. Read `data/business-context.json` — product name, funnels, KPIs
+3. Read `data/competitors.json` — competitor ad strategies
+
+### Step 2: Audience Research
+Use WebSearch to find audience targeting opportunities:
+- `"[product category] facebook ads benchmarks CPM CPC CPA [year]"`
+- `"[product category] facebook ads targeting"`
+- `"[target audience] interests facebook ads"`
+
+Define audience segments:
+
+**Segment 1: Interest-Based (Cold)**
+- Interests: [product category tools], [competitor names], [related technologies]
+- Demographics: [age range], [job titles if B2B]
+- Estimated audience size
+
+**Segment 2: Behavior-Based (Warm)**
+- Behaviors: Technology early adopters, SaaS users, [industry-specific]
+- Layered with interests for precision
+
+**Segment 3: Retargeting (Hot)**
+- Website visitors (last 30 days) who didn't convert
+- Pricing page visitors (last 14 days)
+- Blog readers (last 60 days)
+
+**Segment 4: Lookalike**
+- Based on existing signups/customers
+- 1% lookalike for precision, 3-5% for reach
+
+### Step 3: Campaign Structure
+Design campaigns following Meta Ads best practices:
+
+```
+Campaign: [Product] — Conversions
+├── Ad Set: Interest-Based (Cold)
+│   ├── Audience: [interests + demographics]
+│   ├── Placement: Feed + Stories (auto)
+│   └── Budget: $5/day
+├── Ad Set: Retargeting (Hot)
+│   ├── Audience: Website visitors 30d, excl. signups
+│   ├── Placement: Feed + Stories (auto)
+│   └── Budget: $3/day
+└── Ad Set: Lookalike 1%
+    ├── Audience: Lookalike of signups
+    ├── Placement: Feed + Stories (auto)
+    └── Budget: $5/day
+```
+
+### Step 4: Generate Ad Copy
+For each audience segment, queue copy generation:
+- `/promo-copy ad-meta {audience}` — generates primary text + headline + CTA
+- Match messaging to audience temperature (cold=educate, warm=convince, hot=convert)
+
+### Step 5: Creative Format Recommendations
+For each ad set, recommend creative format:
+- **Cold audiences:** Carousel (3-5 feature cards) or short video (15-30s)
+- **Retargeting:** Single image with social proof / testimonial
+- **Lookalike:** Video demo or before/after comparison
+
+If video skills are available, queue `/promo-video ad-{topic}` for video creatives.
+
+### Step 6: Budget & Schedule
+- **Total daily budget:** $10-15/day starting
+- **Split:** 40% cold, 20% retargeting, 40% lookalike
+- **Schedule:** Run 7 days, then evaluate
+- **Dayparting:** If relevant, focus on business hours for B2B
+
+### Step 7: A/B Test Plan
+For each ad set:
+- Test 2-3 ad copy variations
+- Test 2 creative formats (image vs carousel vs video)
+- Measure for 7 days before declaring winner
+- Winning criteria: lowest CPA or highest CTR (depending on objective)
+
+### Step 8: Tracking
+- UTM parameters: `utm_source=meta&utm_medium=paid&utm_campaign={campaign-slug}&utm_content={ad-set}`
+- Pixel events: ViewContent, Lead, CompleteRegistration
+- CAPI (Conversions API) setup recommendation if not configured
+
+### Step 9: Output
+For each campaign, create an idea in `data/ideas.json` with:
+- Category: "growth"
+- Tags: ["growth", "meta-ads", "{audience-segment}"]
+- Implementation plan with campaign structure
+- Success metrics: impressions, reach, CPM, CPC, CTR, conversions, CPA
+- Budget recommendation
+- Queue `copy-ad-meta-{audience}` tasks
+
+## Output Files
+- `data/ideas.json` — new Meta Ads campaign ideas
+- `data/campaigns/` — campaign briefs (optional)

package/templates/commands/distribution-repurpose.md

@@ -0,0 +1,121 @@
+# /distribution-repurpose — Content Repurposing Pipeline
+
+## Usage
+```
+/distribution-repurpose                     # Repurpose latest shipped idea
+/distribution-repurpose {idea-id}           # Repurpose specific shipped idea
+/distribution-repurpose --content="..."     # Repurpose arbitrary content
+```
+
+## Input
+- `$ARGUMENTS` — optional: idea ID or content to repurpose
+
+## Process
+
+### Step 1: Load Source Content
+1. If idea ID provided, read from `data/ideas.json`
+2. If no argument, find the most recently shipped idea
+3. Read `data/positioning.json` — messaging pillars for consistent voice
+4. Read `data/social.json` — understand which platforms are active
+
+Extract from source:
+- **Title/headline** — the main hook
+- **Key insight** — what's new/interesting
+- **Target audience** — who cares about this
+- **Technical details** — for dev-focused channels
+- **Business impact** — for business-focused channels
+- **Visual assets** — screenshots, diagrams, ship cards
+
+### Step 2: Generate Channel-Specific Adaptations
+
+For each active channel, create a tailored version:
+
+#### Twitter/X Thread (5-7 tweets)
+- Tweet 1: Hook — the most surprising/valuable insight
+- Tweet 2-5: Story arc — problem → solution → result → detail
+- Tweet 6: Takeaway or lesson learned
+- Tweet 7: CTA with link + UTM
+- Use patterns from `ai-content-generator.ts` (hooks, engagement patterns)
+- Queue: `social-draft-thread-{topic}`
+
+#### LinkedIn Post (Professional angle)
+- Opening line: Pattern interrupt or contrarian take
+- Body: "Here's what I learned building [feature]..."
+- Formatting: Short paragraphs, line breaks, no hashtag spam
+- CTA: Soft — "What's your experience with [topic]?"
+- Queue: `copy-social-linkedin`
+
+#### Reddit Post (Value-first, subreddit-adapted)
+- Title: Question or insight format (NOT promotional)
+- Body: Genuine story, metrics shared transparently, lessons learned
+- Adapt tone to target subreddit (technical for r/programming, casual for r/SideProject)
+- Link in context only, never as main content
+- Queue: idea with tags ["growth", "reddit", "{subreddit}"]
+
+#### Google Ads Keyword Group
+- Map content to search intent keywords
+- If content solves a problem → target "[problem] solution" keywords
+- If content is a comparison → target "[product] vs [competitor]" keywords
+- Queue: `copy-ad-google-{keyword}`
+
+#### Meta Retargeting Ad
+- Target: People who visited the content page but didn't convert
+- Creative: Key visual from the content + social proof
+- CTA: Return to complete signup
+- Queue: `copy-ad-meta-retargeting-{content-slug}`
+
+#### Email Newsletter Segment
+- Subject line: Hook adapted for email (curiosity gap)
+- Body: Summary with "read more" link
+- Segment: Users interested in [topic]
+- Queue: `email-blast-{campaign-slug}` or include in next digest
+
+#### Indie Hackers / Dev.to Post
+- Longer form, more transparent about metrics and journey
+- Include code snippets if technical
+- End with question to encourage discussion
+- Cross-post with canonical URL to own blog
+
+### Step 3: UTM Attribution Matrix
+Each adaptation gets consistent tracking:
+
+| Channel | utm_source | utm_medium | utm_campaign |
+|---------|-----------|-----------|-------------|
+| Twitter/X | twitter | social | {content-slug} |
+| LinkedIn | linkedin | social | {content-slug} |
+| Reddit | reddit | community | {content-slug} |
+| Google Ads | google | cpc | {content-slug} |
+| Meta Ads | meta | paid | retarget-{content-slug} |
+| Email | email | newsletter | {content-slug} |
+| Indie Hackers | indiehackers | community | {content-slug} |
+| Dev.to | devto | blog | {content-slug} |
+
+### Step 4: Publishing Schedule
+Stagger publishing for maximum reach:
+
+| Day | Channel | Why |
+|-----|---------|-----|
+| Day 0 | Twitter thread | Immediate, test the hook |
+| Day 1 | LinkedIn post | Business hours reach |
+| Day 2 | Reddit post | Different audience, value-first |
+| Day 3 | Email newsletter | Owned channel, reliable |
+| Day 5 | Dev.to / IH post | Long-form, search indexed |
+| Day 7 | Google Ads | If content validates search intent |
+| Ongoing | Meta retargeting | Runs continuously for page visitors |
+
+### Step 5: Output
+Create ideas in `data/ideas.json` for each channel adaptation:
+- Category: "growth"
+- Tags: ["growth", "repurpose", "{channel}", "{source-idea-id}"]
+- Implementation plan with channel-specific content draft
+- Success metrics: channel-specific (impressions, clicks, referral signups)
+- Queue relevant tasks for each channel
+
+Print summary:
+- Source content: [title]
+- Adaptations generated: [count]
+- Channels covered: [list]
+- Tasks queued: [list]
+
+## Output Files
+- `data/ideas.json` — repurposed content campaign ideas