> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/darkzOGx/youtube-automation-agent/llms.txt
> Use this file to discover all available pages before exploring further.

# Custom Content Types

> Add new content formats and templates to expand your automation capabilities

## Overview

The system comes with built-in content types (Tutorial, Explainer, List, Review, Story), but you can easily add your own custom formats.

## Understanding Content Type Templates

### Template Structure

Content type templates are defined in `agents/script-writer-agent.js:16-44`:

```javascript theme={null}
loadTemplates() {
  return {
    tutorial: {
      structure: ['hook', 'introduction', 'problem', 'solution_steps', 
                  'demonstration', 'recap', 'cta'],
      tone: 'educational',
      pacing: 'moderate'
    },
    explainer: {
      structure: ['hook', 'question', 'background', 'explanation', 
                  'examples', 'implications', 'summary', 'cta'],
      tone: 'informative',
      pacing: 'steady'
    },
    // Add more templates...
  };
}
```

### Template Components

<AccordionGroup>
  <Accordion title="Structure">
    Defines the sections in order. Each section is generated separately and assembled into the final script.

    Common sections:

    * `hook` - Opening attention grabber (required)
    * `introduction` - Video introduction (required)
    * `problem` - Problem statement
    * `solution_steps` - Step-by-step solution
    * `demonstration` - Live demo or walkthrough
    * `explanation` - Detailed explanation
    * `examples` - Real-world examples
    * `list_items` - Numbered or bulleted list
    * `comparison` - Comparison with alternatives
    * `recap` - Summary of key points
    * `cta` - Call to action (required)
  </Accordion>

  <Accordion title="Tone">
    The overall voice and style of the content:

    * `educational` - Teaching and instructional
    * `informative` - Fact-based and neutral
    * `engaging` - Entertaining and dynamic
    * `analytical` - In-depth and thoughtful
    * `narrative` - Story-driven
    * `conversational` - Casual and friendly
  </Accordion>

  <Accordion title="Pacing">
    Content delivery speed:

    * `quick` - Fast-paced, energetic
    * `moderate` - Balanced pace
    * `steady` - Consistent, measured
    * `detailed` - Slower, comprehensive
    * `dynamic` - Varied pace throughout
  </Accordion>
</AccordionGroup>

## Creating Custom Content Types

### Example: Product Showcase Template

Let's create a "Product Showcase" content type for reviewing products:

```javascript agents/script-writer-agent.js theme={null}
loadTemplates() {
  return {
    // Existing templates...
    
    showcase: {
      structure: [
        'hook',
        'introduction',
        'product_overview',
        'unboxing',
        'features',
        'demonstration',
        'pros',
        'cons',
        'price_value',
        'verdict',
        'cta'
      ],
      tone: 'enthusiastic',
      pacing: 'dynamic'
    },
    
    interview: {
      structure: [
        'hook',
        'introduction',
        'guest_intro',
        'background',
        'questions',
        'key_insights',
        'advice',
        'summary',
        'cta'
      ],
      tone: 'conversational',
      pacing: 'moderate'
    },
    
    challenge: {
      structure: [
        'hook',
        'introduction',
        'challenge_rules',
        'preparation',
        'attempt',
        'results',
        'lessons_learned',
        'recap',
        'cta'
      ],
      tone: 'exciting',
      pacing: 'quick'
    }
  };
}
```

### Implementing Section Generators

Add generators for custom sections in `agents/script-writer-agent.js:221-476`:

```javascript theme={null}
async generateSection(sectionType, strategy) {
  const sectionGenerators = {
    // Existing generators...
    
    product_overview: () => this.generateProductOverview(strategy),
    unboxing: () => this.generateUnboxing(strategy),
    features: () => this.generateFeatures(strategy),
    price_value: () => this.generatePriceValue(strategy),
    verdict: () => this.generateVerdict(strategy),
    
    guest_intro: () => this.generateGuestIntro(strategy),
    questions: () => this.generateQuestions(strategy),
    key_insights: () => this.generateKeyInsights(strategy),
    
    challenge_rules: () => this.generateChallengeRules(strategy),
    preparation: () => this.generatePreparation(strategy),
    attempt: () => this.generateAttempt(strategy),
    results: () => this.generateResults(strategy),
    lessons_learned: () => this.generateLessonsLearned(strategy)
  };

  const generator = sectionGenerators[sectionType];
  
  if (generator) {
    return await generator();
  }
  
  return this.generateGenericSection(sectionType, strategy);
}

// Implement the custom section generators
async generateProductOverview(strategy) {
  return {
    type: 'product_overview',
    title: 'What Is It?',
    content: [
      `Today we're taking a detailed look at ${strategy.topic}.`,
      `This product has been making waves in the market.`,
      `Let me give you the complete overview of what it offers.`,
      `[Show product on camera]`
    ],
    visuals: ['Product beauty shots', 'Brand logo'],
    duration: 45
  };
}

async generateUnboxing(strategy) {
  return {
    type: 'unboxing',
    title: 'Unboxing Experience',
    content: [
      `Let's start with the unboxing experience.`,
      `First impressions matter, and the packaging is impressive.`,
      `[Open box and reveal contents]`,
      `Here's what you get in the box...`,
      `The presentation definitely feels premium.`
    ],
    visuals: ['Unboxing footage', 'Contents laid out'],
    duration: 60
  };
}

async generateFeatures(strategy) {
  const features = [
    'Innovative design and build quality',
    'Advanced performance capabilities',
    'User-friendly interface',
    'Excellent connectivity options',
    'Long battery life'
  ];
  
  return {
    type: 'features',
    title: 'Key Features',
    content: [
      `Now let's dive into the features that make this special.`,
      ...features.map((f, i) => `Feature ${i + 1}: ${f}`),
      `Each of these features adds real value.`
    ],
    features: features,
    visuals: ['Feature demonstrations', 'Close-up shots'],
    duration: 90
  };
}

async generatePriceValue(strategy) {
  return {
    type: 'price_value',
    title: 'Is It Worth The Price?',
    content: [
      `Let's talk about the price and value proposition.`,
      `At the current price point, you're getting a lot.`,
      `Compared to similar products in this category...`,
      `The value here is definitely competitive.`
    ],
    visuals: ['Price comparison chart'],
    duration: 30
  };
}

async generateVerdict(strategy) {
  return {
    type: 'verdict',
    title: 'Final Verdict',
    content: [
      `So here's my final verdict on ${strategy.topic}.`,
      `Who should buy this?`,
      `Who should skip it?`,
      `Overall, I'd rate this [X/10].`,
      `For the right person, this is absolutely worth it.`
    ],
    visuals: ['Rating graphic', 'Summary card'],
    duration: 45
  };
}
```

## Configuring Content Strategy

### Adding Content Type to Strategy Agent

Update the content type selection in `agents/content-strategy-agent.js:312-331`:

```javascript theme={null}
selectContentType(topic) {
  const types = [
    // Existing types...
    { type: 'Tutorial', suitableFor: ['how to', 'guide', 'learn'] },
    { type: 'List', suitableFor: ['best', 'top', 'worst'] },
    { type: 'Review', suitableFor: ['review', 'vs', 'comparison'] },
    { type: 'Explainer', suitableFor: ['what is', 'why', 'explained'] },
    
    // Add custom types
    { type: 'Showcase', suitableFor: ['product', 'showcase', 'unboxing'] },
    { type: 'Interview', suitableFor: ['interview', 'conversation', 'talk'] },
    { type: 'Challenge', suitableFor: ['challenge', 'attempt', 'trying'] }
  ];

  const topicLower = topic.toLowerCase();
  
  for (const contentType of types) {
    if (contentType.suitableFor.some(keyword => topicLower.includes(keyword))) {
      return contentType.type;
    }
  }

  return 'Explainer';
}
```

### Configuring Available Content Types

Update your credentials configuration to enable custom types:

```json config/credentials.json theme={null}
{
  "content": {
    "contentTypes": [
      "tutorial",
      "explainer",
      "list",
      "review",
      "story",
      "showcase",
      "interview",
      "challenge"
    ],
    "postingFrequency": "daily",
    "preferredPostTime": "14:00"
  }
}
```

## Advanced Template Customization

### Dynamic Section Generation

Create templates that adapt based on topic:

```javascript theme={null}
loadTemplates() {
  return {
    adaptive: {
      structure: (topic) => {
        const base = ['hook', 'introduction'];
        
        // Add sections based on topic
        if (topic.includes('tutorial')) {
          base.push('problem', 'solution_steps', 'demonstration');
        } else if (topic.includes('review')) {
          base.push('overview', 'pros', 'cons', 'verdict');
        } else {
          base.push('explanation', 'examples');
        }
        
        base.push('recap', 'cta');
        return base;
      },
      tone: 'adaptive',
      pacing: 'moderate'
    }
  };
}
```

### Template Variants

Create variants for different video lengths:

```javascript theme={null}
loadTemplates() {
  return {
    'tutorial-short': {
      structure: ['hook', 'introduction', 'quick_steps', 'recap', 'cta'],
      tone: 'educational',
      pacing: 'quick',
      targetDuration: '3-5 minutes'
    },
    'tutorial-long': {
      structure: ['hook', 'introduction', 'problem', 'theory',
                  'detailed_steps', 'demonstration', 'common_mistakes',
                  'advanced_tips', 'recap', 'cta'],
      tone: 'educational',
      pacing: 'detailed',
      targetDuration: '15-20 minutes'
    }
  };
}
```

## SEO Optimization for Custom Types

### Custom Title Patterns

Add title patterns for your content types in `agents/script-writer-agent.js:92-113`:

```javascript theme={null}
async generateTitle(strategy) {
  // Custom titles for custom content types
  const customTitles = {
    Showcase: [
      `${strategy.topic}: Complete Unboxing & Review`,
      `Is ${strategy.topic} Worth It? Honest Review`,
      `${strategy.topic} - Everything You Need to Know`
    ],
    Interview: [
      `Expert Insights: ${strategy.topic}`,
      `In Conversation: ${strategy.topic}`,
      `${strategy.topic} - Behind the Scenes`
    ],
    Challenge: [
      `I Tried ${strategy.topic} for 30 Days`,
      `${strategy.topic} Challenge - The Results`,
      `Can I ${strategy.topic}? The Ultimate Test`
    ]
  };

  if (customTitles[strategy.contentType]) {
    const titles = customTitles[strategy.contentType];
    return titles[Math.floor(Math.random() * titles.length)];
  }

  // Fall back to default title generation
  return `${strategy.angle}`;
}
```

<Note>
  Custom content types should align with your channel's niche and audience expectations. Test new formats gradually before automating them.
</Note>

## Testing Custom Content Types

### Manual Generation

Test your custom content type:

```javascript test-custom-type.js theme={null}
const { YouTubeAutomationAgent } = require('./index');

async function testCustomContentType() {
  const agent = new YouTubeAutomationAgent();
  await agent.initialize();
  
  // Generate content with custom type
  const result = await agent.generateContent(
    'Best Wireless Headphones 2025',
    'showcase',
    'medium'
  );
  
  console.log('Generated content:', result);
  console.log('Content ID:', result.contentId);
}

testCustomContentType().catch(console.error);
```

### Validation

```bash theme={null}
node test-custom-type.js
```

<Warning>
  Before deploying custom content types to production:

  * Generate at least 3-5 test videos
  * Review script quality and coherence
  * Check SEO optimization effectiveness
  * Validate thumbnail generation compatibility
  * Ensure proper database storage
</Warning>

## Database Schema Extensions

Store custom content type metadata:

```javascript theme={null}
// Add to database/db.js
async createContentTypeMetadata() {
  await this.executeQuery(`
    CREATE TABLE IF NOT EXISTS content_type_metadata (
      id TEXT PRIMARY KEY,
      content_type TEXT NOT NULL,
      performance_score REAL DEFAULT 0,
      total_uses INTEGER DEFAULT 0,
      average_views INTEGER DEFAULT 0,
      average_retention REAL DEFAULT 0,
      best_performing_video TEXT,
      configuration TEXT,
      created_at TEXT DEFAULT CURRENT_TIMESTAMP
    )
  `);
}

async trackContentTypePerformance(contentType, videoId, metrics) {
  const existing = await this.getRow(
    'SELECT * FROM content_type_metadata WHERE content_type = ?',
    [contentType]
  );
  
  if (existing) {
    // Update existing metrics
    await this.executeQuery(`
      UPDATE content_type_metadata SET
        total_uses = total_uses + 1,
        average_views = (average_views * total_uses + ?) / (total_uses + 1),
        average_retention = (average_retention * total_uses + ?) / (total_uses + 1),
        performance_score = (average_views / 1000) * average_retention
      WHERE content_type = ?
    `, [metrics.views, metrics.retention, contentType]);
  } else {
    // Insert new record
    await this.executeQuery(`
      INSERT INTO content_type_metadata (
        id, content_type, total_uses, average_views, 
        average_retention, best_performing_video
      ) VALUES (?, ?, 1, ?, ?, ?)
    `, [
      this.generateId('ct_meta'),
      contentType,
      metrics.views,
      metrics.retention,
      videoId
    ]);
  }
}
```

## Next Steps

<CardGroup cols={2}>
  <Card title="Customization" icon="wrench" href="/advanced/customization">
    More customization options
  </Card>

  <Card title="Troubleshooting" icon="screwdriver-wrench" href="/advanced/troubleshooting">
    Debug and resolve issues
  </Card>
</CardGroup>