Automating Content Creation: How OpenAI's GPT-4o Transforms Blogging

In today's fast-paced digital world, blogs can really benefit from automating content creation. Let me introduce you to a fantastic feature of this blog: we use OpenAI's incredible GPT-4o and TypeScript to generate articles automatically. Intrigued? Let’s dive into how it works!

Get Started with Automated Content Creation

The magic happens with our create-article.ts script, which generates articles from a slug or even commit details. Here’s a simplified version of how it works:

1. SEO-Friendly Slugs: Ensures each article's slug is unique and SEO-friendly for better search engine visibility.
2. Markdown Format: Articles are written in Markdown, making them easy to write and read.
3. Flexible Input: You can use command-line options to specify slugs and commits for content ideas.

The Power of OpenAI and TypeScript

Our blog uses OpenAI's API to not only create article content but also generate essential metadata. This means the system can craft a captivating title, description, tags, and categories, all tailored to make your content shine online.

How It Enhances Content Creation

• Unique Slugs: Makes sure every article is accessible and easy to find.
• Markdown Simplicity: Markdown's straightforward syntax is perfect for seamless writing and formatting.

Continuous Improvement

We believe in constantly refining our processes. And realize that this need a lot of refinement to, for example, express more of my personality, and less of a generic AI style.

Behind the Scenes: The createArticle Function

Here's a peek at the core piece of our automation – the createArticle function in TypeScript:

const createArticle = async (slug?: string, commits?: string[]): Promise<void> => {
  if (!slug && (!commits || commits.length === 0)) {
    throw new Error('Either slug or commits must be provided.');
  }

  const articlesDir = path.join(process.cwd(), 'blog/src/articles');
  const date = new Date().toISOString().split('T')[0];
  // Get existing articles for context
  const existingArticles = fs.readdirSync(articlesDir)
    .filter(file => file.endsWith('.mdx') && file !== 'article-template.mdx')
    .map(file => fs.readFileSync(path.join(articlesDir, file), 'utf8'))
    .map(fileContent => matter(fileContent).data);

  // Expand commit IDs using git show
  execSync('git config --local commit.verbose 1');
  const expandedCommits = commits ? commits.map(commit => execSync(`git show ${commit}`).toString()) : [];

  // Generate metadata and content using OpenAI
  const systemPrompt = `
    You are an expert content creator. Generate a title, description, tags, categories, and a first draft of the article based on the following context:
    - Slug: ${slug || 'N/A'}
    - Commit Details: ${expandedCommits.join('\n')}
    - Existing Articles: ${JSON.stringify(existingArticles)}
    - You respond in JSON format only.
    {
      "title": "string",
      "description": "string",
      "tags": ["string"],
      "categories": ["string"],
      "links": ["string"],
      "processed": false,
      "grade": 0,
      "content": "string",
      "slug": "string"
    }
  `;

  const response = await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [
      { role: 'system', content: systemPrompt },
      { role: 'user', content: `Generate metadata and content for the article.` }
    ],
  });

  let result;
  try {
    result = JSON.parse(response.choices[0].message?.content || '{}');
  } catch (error) {
    console.error('Failed to parse OpenAI response as JSON:', response.choices[0].message?.content);
    throw new Error('Invalid JSON response from OpenAI');
  }

  const newSlug = slug || result.slug;
  isValidSlug(newSlug);
  const newArticlePath = path.join(articlesDir, `${newSlug}.mdx`);

  const newMetadata: Metadata = {
    title: result.title,
    date,
    updated: date,
    description: result.description,
    tags: result.tags,
    categories: result.categories,
    links: result.links,
    processed: false,
    grade: 0,
  };

  const newContent = result.content;

  // Write the new article
  const newArticle = matter.stringify(newContent, newMetadata);
  fs.writeFileSync(newArticlePath, newArticle, 'utf8');

  console.log(`Article ${newSlug} created successfully.`);
};

Conclusion

Engaging with cutting-edge technologies like OpenAI's GPT-4o and automation practices isn't just a novelty – it genuinely boosts efficiency and enhances the quality of content on this blog. Give it a try and see the magic unfold!