How to Build a Skill-Based Content Repurposing System with Claude Code

The Case for Automating Content Repurposing

Most content creators and marketers know the drill: you spend three hours recording a great YouTube video, then another two hours manually chopping it into a LinkedIn post, a newsletter section, and a handful of ad variations. By the end, you’ve done more editing work than you did filming.

A skill-based content repurposing system changes that. Instead of rewriting manually, you wire up an AI agent — built with Claude Code — that pulls your video transcript, understands what format each platform needs, and produces finished drafts automatically. One input, five outputs, minimal human involvement.

This guide walks through how to build that system from scratch. We’ll cover the architecture, the individual “skills” your agent needs, and how to wire them together into a repeatable workflow. By the end, you’ll have a working content repurposing system that can turn a single YouTube video into LinkedIn posts, newsletter copy, ad scripts, and more — on demand.

---

What “Skill-Based” Actually Means Here

The term “skill-based” comes from a specific architectural pattern in AI agent design. Instead of building one monolithic prompt that tries to do everything, you break the agent’s capabilities into discrete, reusable skills — each one responsible for a specific output type.

Think of it this way:

• Skill 1: Fetch and transcribe a YouTube video
• Skill 2: Extract core themes and key quotes
• Skill 3: Write a LinkedIn post from the transcript
• Skill 4: Write a newsletter section from the transcript
• Skill 5: Generate short-form ad copy variations

Each skill is a self-contained unit. Claude Code orchestrates them, deciding which ones to invoke and in what order based on what output you’re targeting.

This approach has real advantages over monolithic prompts. Skills can be tested and improved individually. New output formats can be added without breaking existing ones. And the same core skills — like “extract themes” — can be reused across different workflows.

---

Prerequisites

Before building, make sure you have the following in place:

• Claude Code installed and running locally (Anthropic’s agentic coding tool)
• A YouTube video URL to test against
• Node.js 18+ installed
• A MindStudio account — needed to access the Agent Skills Plugin (free to start)
• Basic comfort with terminal commands and reading JSON

You don’t need to be an expert developer. Claude Code will write most of the actual code for you. Your job is to design the architecture, write the prompts for each skill, and test the outputs.

---

Step 1: Design Your Skill Map

Before writing a single line of code, map out the skills your system needs. This is the most important design decision you’ll make — get it right here and everything downstream becomes easier.

A solid starting point for a YouTube-to-multi-platform system looks like this:

Input skills (data gathering):

• fetchTranscript(videoUrl) — pulls the YouTube transcript
• extractMetadata(videoUrl) — gets title, description, chapter markers

Processing skills (analysis):

• extractThemes(transcript) — identifies 3–5 core ideas
• extractQuotes(transcript) — pulls strong, standalone quotes
• summarize(transcript, length) — creates a short, medium, or long summary

Output skills (content generation):

• writeLinkedInPost(themes, quotes) — formats for LinkedIn audience
• writeNewsletter(summary, themes) — formats for email newsletter
• writeAdCopy(quotes, themes) — generates 3–5 short ad variations
• writeTweetThread(themes, quotes) — creates a numbered thread format

Each skill should have a clear input, a clear output, and a focused prompt. Don’t try to make one skill do two jobs.

---

Step 2: Set Up the Project Structure

Open your terminal and create a new project directory. Then tell Claude Code what you’re building:

You are building a content repurposing agent. Create a Node.js project structure with:
- An `index.js` entry point
- A `/skills` folder for individual skill modules
- A `/prompts` folder for prompt templates
- A `/outputs` folder for generated content
- A `package.json` with relevant dependencies

The agent will accept a YouTube URL as input and produce multiple content formats as output.

Claude Code will scaffold the project. Review what it creates — you want clean separation between the orchestration logic (index.js), the individual skills (/skills), and the prompts (/prompts).

One thing to check: make sure your prompts are stored as separate files, not hardcoded strings. This makes iterating on them far easier later.

---

Step 3: Build the Transcript Fetching Skill

The transcript fetch is your foundation. Everything else depends on it being accurate and clean.

For YouTube, the most reliable approach is using the youtube-transcript npm package, which pulls auto-generated or manually uploaded captions without requiring the YouTube Data API.

Prompt Claude Code with:

Create a skill module at /skills/fetchTranscript.js that:
1. Accepts a YouTube URL as input
2. Uses the youtube-transcript package to fetch the transcript
3. Cleans the output (removes timestamps, merges short segments)
4. Returns the full text as a single string
5. Handles errors gracefully with clear error messages

Once Claude Code writes this, test it immediately with a real video. The cleaner your transcript, the better your downstream outputs will be.

A few common issues to watch for:

• Videos without captions will fail — add a check for this
• Auto-generated transcripts often lack punctuation — consider adding a cleaning step that uses Claude to add punctuation before passing to other skills
• Very long videos (60+ minutes) may produce transcripts that exceed Claude’s context window — plan for chunking if you’re targeting long-form content

---

Step 4: Build the Analysis Skills

With a clean transcript in hand, the next layer is analysis. These skills extract the raw material that your output skills will use.

Theme Extraction

Create a skill module at /skills/extractThemes.js that:
- Accepts a transcript string as input
- Uses Claude API to identify the 3–5 main themes or arguments
- Returns an array of theme objects, each with a title and 2-sentence description
- Instructs Claude to prioritize themes that would be interesting to a professional audience

Quote Extraction

Create a skill module at /skills/extractQuotes.js that:
- Accepts a transcript string as input
- Identifies 5–8 strong standalone quotes or statements
- Prioritizes quotes that are surprising, contrarian, specific, or data-backed
- Returns an array of quote strings, each under 280 characters

The 280-character limit on quotes is intentional — it keeps them usable for Twitter/X without modification, and short enough for ad copy.

Summarization

Build a flexible summarization skill that accepts a length parameter:

• Short: 2–3 sentences for social media captions
• Medium: 1 paragraph for newsletter intros
• Long: 3–4 paragraphs for full newsletter sections

This single skill handles three different use cases, which keeps your skill count manageable.

---

Step 5: Build the Output Skills

This is where the content actually gets generated. Each output skill has a specific audience and format in mind.

LinkedIn Post Skill

LinkedIn rewards a specific structure: a hook line, a short body with white space, and a clear takeaway. Build your prompt around this:

Create a skill module at /skills/writeLinkedInPost.js that:
- Accepts themes array and quotes array as input
- Generates a LinkedIn post following this structure:
  - Line 1: Bold hook (question, contrarian statement, or surprising fact)
  - Lines 2–8: Short paragraphs, 1–2 sentences each, with line breaks
  - Final line: Clear takeaway or question to drive comments
- Keeps total length to 150–200 words
- Avoids hashtag overuse (max 3, at the end)
- Does NOT start with "I" or sound like a press release

The “does not start with I” instruction is small but important — LinkedIn posts that start with “I” feel self-promotional and get less engagement.

Newsletter Section Skill

Newsletter copy has a different voice than LinkedIn — more conversational, more depth, and readers expect to be taught something.

Create a skill module at /skills/writeNewsletter.js that:
- Accepts summary (medium length) and themes array as input
- Generates a newsletter section with:
  - A subject line suggestion
  - A 3–4 paragraph body that explains the main idea
  - A "what this means for you" paragraph at the end
  - A call-to-action sentence
- Writes in second person ("you") throughout
- Targets a professional audience interested in the topic

Ad Copy Skill

Ad copy is the shortest format but requires the most precision. Your agent should generate multiple variations so you can test them.

Create a skill module at /skills/writeAdCopy.js that:
- Accepts quotes array and themes array as input
- Generates 5 short ad copy variations (under 100 characters each)
- For each variation, also generates a 25-word body text
- Tags each variation with a "hook type": curiosity, social proof, pain point, benefit, or contrarian
- Returns an array of variation objects with fields: headline, body, hookType

Tagging by hook type is a practical touch — it lets you run structured A/B tests rather than random ones.

---

Step 6: Wire the Orchestration Layer

With all your skills built, the orchestration layer is what ties them together. This is where Claude Code does its best work — you describe the logic, it writes the coordination code.

Create an orchestration function in index.js that:
1. Accepts a YouTube URL and a list of desired output formats as inputs
2. Runs fetchTranscript and extractMetadata in parallel
3. Then runs extractThemes, extractQuotes, and summarize in parallel (using the transcript)
4. Then runs the appropriate output skills in parallel based on requested formats
5. Saves all outputs to the /outputs folder as individual markdown files
6. Logs progress to the console at each step
7. Returns a summary object with file paths and word counts for each output

The key design choice here is parallel execution wherever possible. Theme extraction and quote extraction don’t depend on each other, so they can run simultaneously. This cuts your total runtime significantly compared to running each skill sequentially.

A realistic runtime for a 30-minute video, running all output skills:

• Transcript fetch: 3–5 seconds
• Analysis skills (parallel): 8–12 seconds
• Output skills (parallel): 10–15 seconds
• Total: ~25–35 seconds

That’s a full content package from one URL in under a minute.

---

Step 7: Add a Quality Control Layer

Raw AI outputs need a review pass. Build a lightweight QC skill that flags issues before you save the final files.

This skill doesn’t rewrite content — it just surfaces problems:

Create a skill module at /skills/qualityCheck.js that:
- Accepts any content string and a format type as input
- Checks for: excessive length, missing calls-to-action, AI-sounding phrases, passive voice overuse
- Returns a quality object with: passedCheck (boolean), issues (array of strings), score (1–10)
- Does NOT modify the content — only flags it

Wire this into the orchestration layer so every output gets checked before saving. Flag anything with a score below 7 for human review.

This one addition significantly improves output quality over time. When you see the same issue flagged repeatedly, you know to improve that skill’s prompt.

---

How MindStudio’s Agent Skills Plugin Fits Into This

Building the Claude Code agent above handles the reasoning and content generation. But there are actions your agent will eventually need to take that go beyond writing to a file.

What if you want the agent to:

• Post the LinkedIn content via the LinkedIn API automatically
• Send the newsletter draft to your email platform
• Save outputs to a Notion database
• Search Google to enrich the content with current data

This is where MindStudio’s Agent Skills Plugin becomes relevant. It’s an npm SDK (@mindstudio-ai/agent) that gives any Claude Code agent — or any AI agent, for that matter — access to 120+ typed capabilities as simple method calls.

Instead of building your own LinkedIn API integration or setting up email infrastructure, you call:

await agent.sendEmail({ to: "editor@company.com", subject: "New content batch", body: output });
await agent.searchGoogle({ query: `${themes[0].title} statistics 2024` });
await agent.runWorkflow({ workflowId: "notion-save", data: outputs });

The SDK handles rate limiting, retries, and auth — your agent just calls the method and gets a result.

For a content repurposing system, the most useful integrations from the plugin are:

• searchGoogle() — pull current stats or examples to enrich generated content
• sendEmail() — deliver newsletter drafts directly to your email tool
• runWorkflow() — trigger downstream MindStudio workflows (like auto-posting to social media)
• generateImage() — create social images to pair with your written content

Installing it takes about 30 seconds:

npm install @mindstudio-ai/agent

Then initialize with your MindStudio API key and start calling skills. You can try MindStudio free at mindstudio.ai.

If you’d rather build the entire workflow visually — without Claude Code — MindStudio’s no-code builder can handle the same content repurposing logic with drag-and-drop. The AI workflow builder supports 200+ AI models and 1,000+ integrations, so you can connect your transcript pipeline to publishing tools without writing any infrastructure code.

---

Common Mistakes to Avoid

Building this kind of system is straightforward once you know the pitfalls. Here are the ones that show up most often:

Over-engineering the prompt

Longer prompts don’t always produce better output. If your LinkedIn post prompt is 500 words of instructions, Claude will often fixate on following the instructions rather than writing naturally. Keep individual skill prompts under 200 words. Specificity beats length.

Skipping the cleaning step

Running a raw transcript directly through output skills produces rough results. Auto-generated captions lack punctuation, include filler words, and break mid-sentence. A 10-second cleaning pass — either with a regex script or a small Claude prompt — meaningfully improves every downstream output.

Building all outputs simultaneously before testing

It’s tempting to wire up the full pipeline before testing any individual skill. Don’t. Test each skill in isolation with real transcript data before connecting them. You’ll find prompt issues much faster this way.

Using the same voice for every platform

LinkedIn, email, and ad copy have different audiences and different conventions. If your LinkedIn post sounds like an email newsletter, it won’t perform. Build platform-specific voice instructions into each output skill — don’t assume a neutral tone will work everywhere.

Not saving your prompts as versioned files

Your prompts will change as you improve the system. If they’re hardcoded strings in your JavaScript files, you’ll lose track of what changed and why. Store prompts as named .txt or .md files in your /prompts folder, and commit them to version control.

---

Extending the System

Once your base system is running, there are several natural extensions worth considering:

Add a Notion or Airtable output — instead of markdown files, write directly to a content database where your team can review and approve

Build a batch mode — accept a playlist URL and process multiple videos in sequence, useful for repurposing a back-catalog

Add a tone slider — give each output skill a tone parameter (formal, casual, technical) so the same content can be adapted for different audiences

Connect to a scheduling tool — once content is approved, route it to Buffer or Hootsuite automatically via the MindStudio Agent Skills Plugin’s workflow methods

Add image generation — pair the LinkedIn post with an AI-generated graphic using agent.generateImage() for higher-engagement posts

Each extension is a new skill added to the map. The orchestration logic stays the same — you just add new branches.

---

Frequently Asked Questions

Can this system work with content other than YouTube videos?

Yes. The transcript fetch skill is the only piece tied to YouTube. If you swap it for a podcast transcript (via RSS or a transcription service), a blog post URL, or a PDF upload, the rest of the pipeline works identically. The analysis and output skills operate on plain text — they don’t care where it came from.

How accurate are auto-generated YouTube transcripts?

For clearly spoken English content, auto-generated transcripts are typically 90–95% accurate. Technical jargon, proper nouns, and heavy accents lower that number. For high-stakes content, it’s worth running the transcript through a cleaning prompt that fixes obvious errors before passing it to output skills.

How do I make sure the outputs don’t all sound the same?

This comes down to prompt specificity. Each output skill should explicitly describe the platform’s conventions, audience expectations, and voice. Vague instructions like “write engagingly” produce generic outputs. Specific instructions like “use contrarian framing, avoid jargon, start with a counterintuitive statement” produce distinct ones. Also vary the source material each skill draws from — LinkedIn posts might emphasize quotes while newsletters emphasize themes.

What’s the difference between this and just using ChatGPT manually?

Manual ChatGPT use requires you to paste in transcripts, craft prompts, wait for outputs, and copy results to wherever you need them — every single time. A skill-based system does all of that automatically, consistently, and in parallel. The output quality is similar, but the time cost drops from 90+ minutes to under 5 minutes of review. At scale, across dozens of videos, that’s a significant operational difference.

Do I need to know how to code to build this?

Claude Code writes the implementation for you based on your descriptions. What you actually need is the ability to describe what you want clearly, read and understand code at a high level, test outputs, and iterate on prompts. Most people with non-technical backgrounds can manage this workflow with some practice.

How do I handle videos that are too long for Claude’s context window?

For videos over about 60 minutes, the transcript will exceed practical context window limits. The solution is chunking: split the transcript into segments, run your analysis skills on each chunk separately, then run a synthesis step that merges the theme and quote arrays before feeding them into output skills. Claude Code can build this chunking logic for you if you describe the problem.

---

Key Takeaways

• A skill-based content repurposing system treats each output format as a separate, testable capability rather than one large prompt
• Claude Code can scaffold and write most of the implementation — your job is to design the architecture and write focused prompts
• The system architecture follows three layers: input (fetch/clean), analysis (extract themes/quotes/summary), and output (platform-specific generation)
• Parallel execution across skills keeps total runtime under a minute for most videos
• MindStudio’s Agent Skills Plugin extends Claude Code agents with 120+ callable capabilities — including posting, email delivery, and external search — without building custom integrations
• Testing each skill in isolation before wiring the pipeline saves significant debugging time

Content repurposing doesn’t have to be a manual bottleneck. With the right skill architecture, a single piece of source content can fan out into a full content calendar automatically. If you want to extend this system with integrations — email delivery, social posting, database storage — MindStudio’s Agent Skills Plugin gives your Claude Code agent the infrastructure to do it with a few method calls. Start free and see how far one video can go.