Content Generation

Content workflows generate platform-native text — captions, posts, ad copy, and multi-part series — with tone control and media awareness for each social platform.

Platform Text Adaptation

Workflow: global/platform-adapt

Takes a single hook or concept and produces platform-native text for each target platform. Each output respects the platform’s character limits, media context, formatting conventions, and cultural voice.

CLI
REST

# Caption mode — text to accompany an image or video
fab-workflow global/platform-adapt \
  --input hook_text="3 things nobody tells you about cold showers" \
  --input platforms=instagram,linkedin,twitter,tiktok \
  --input mode=caption \
  --input visual_description="person stepping into ice bath at sunrise"

# Standalone mode — self-contained text posts
fab-workflow global/platform-adapt \
  --input hook_text="3 things nobody tells you about cold showers" \
  --input platforms=twitter,linkedin,threads \
  --input mode=standalone \
  --input tone_mode=conversational

curl -X POST "$FABRIC_URL/v1/workflows/run?name=global/platform-adapt" \
  -H "Authorization: Bearer $FABRIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "hook_text": "3 things nobody tells you about cold showers",
      "platforms": ["instagram", "linkedin", "twitter", "tiktok"],
      "mode": "caption",
      "visual_description": "person stepping into ice bath at sunrise"
    }
  }'

Two Modes

Mode	Use Case	Text Relationship to Visual
`caption`	Instagram post, TikTok video, YouTube description	References and complements the visual
`standalone`	Tweet thread, LinkedIn article, Threads post	Text carries the full message

Tone Modes

All text-generating workflows support a tone_mode parameter:

Tone	Description	Best For
`aggressive`	Scroll-stopping, bold, provocative. Every word earns its place.	Short-form video hooks, attention-grabbing posts
`narrative`	Storytelling warmth, vulnerability, emotional arc. The reader should feel something.	Instagram captions, LinkedIn posts, series content
`conversational`	Casual first-person, like texting a smart friend. Relatable over impressive.	Threads, Twitter, community engagement

Platform Specs

Each platform has built-in constraints for character limits, hashtag strategy, dominant media type, and voice:

Platform	Primary Media	Max Chars	Target Length	Hashtags
`twitter`	Text-first, often with image	280	Fit in limit	1-3
`linkedin`	Text-first, optional image/doc	3,000	~200 words	3-5
`instagram`	Image or video, always	2,200	~150 words	20-30
`threads`	Text-first, optional image	500	Fit in limit	0-2
`facebook`	Mixed (video, image, link, text)	63,206	~200 words	1-3
`reddit`	Text or link post	40,000	~250 words	None
`tiktok`	Video, always	2,200	~50 words	3-5
`youtube`	Video, always	5,000	~200 words	3-5

Input

Parameter	Type	Default	Description
`hook_text`	`string`	required	Core hook or concept to adapt
`topic`	`string`	`""`	Broader topic context
`platforms`	`string` or `list`	`["instagram", "linkedin", "twitter"]`	Target platforms (comma-separated or list)
`mode`	`string`	`"caption"`	`"caption"` or `"standalone"`
`tone_mode`	`string`	`"aggressive"`	`"aggressive"`, `"narrative"`, or `"conversational"`
`visual_description`	`string`	`""`	What the image/video shows (caption mode)
`brand_voice`	`string`	`""`	Brand voice guidelines
`target_audience`	`string`	`""`	Audience description
`niche`	`string`	`""`	Content niche

Output

{
  "platform_texts": [
    {
      "platform": "twitter",
      "text": "Nobody tells you this about cold showers: the benefits kick in at week 3, not day 1. Most people quit at day 5.",
      "hashtags": ["coldshowers", "biohacking"],
      "char_count": 112,
      "tone_mode": "conversational",
      "is_thread": false,
      "thread_tweets": null
    },
    {
      "platform": "linkedin",
      "text": "I've taken cold showers every morning for 6 months.\n\nHere's what nobody tells you:\n\nThe first week is pure willpower...",
      "hashtags": ["wellness", "habits", "coldexposure"],
      "char_count": 847,
      "tone_mode": "conversational",
      "is_thread": false,
      "thread_tweets": null
    }
  ]
}

For Twitter, if the concept needs more than 280 characters, the system produces a thread:

{
  "platform": "twitter",
  "text": "Nobody tells you this about cold showers:",
  "is_thread": true,
  "thread_tweets": [
    "Nobody tells you this about cold showers:",
    "The benefits don't kick in at day 1. They kick in at week 3...",
    "Here's what actually happens to your body..."
  ]
}

Digital Product Factory

Workflow: content/digital-product

End-to-end workflow that generates a complete sellable digital product from a topic or niche. Discovers real problems from Reddit, identifies the highest-value audience, generates hooks, designs a solution, creates a professionally designed PDF guide (V1 basic + V2 premium), a conversion-optimized landing page, Gumroad copy, social media visuals, an email launch sequence, and a full distribution pack.

CLI
REST

# Minimal — topic only
fab-workflow content/digital-product \
  --input topic="AI security for founders"

# Full control
fab-workflow content/digital-product \
  --input topic="meal prep for busy parents" \
  --input product_type=checklist \
  --input price_range='$9-$14' \
  --input platforms=instagram,tiktok,twitter \
  --input tone_mode=conversational

curl -X POST "$FABRIC_URL/v1/workflows/run?name=content/digital-product" \
  -H "Authorization: Bearer $FABRIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "topic": "AI security for founders",
      "price_range": "$19-$29",
      "product_type": "guide",
      "platforms": ["twitter", "linkedin", "tiktok", "instagram"]
    }
  }'

Pipeline

research_reddit → select_audience → lock_brand_voice → refine_problems →
generate_hooks → design_solution →
fork(
  branch: structure_pdf → generate_v1 → quality_gate → generate_v2,
  branch: generate_pdf_design
) → render_pdf →
fork(
  branch: landing_page,
  branch: gumroad_page,
  branch: social_visuals,
  branch: distribution_pack,
  branch: email_sequence
) → package_output

Input

Parameter	Type	Default	Description
`topic`	`string`	required	Topic or niche (e.g. “AI security for founders”)
`niche_override`	`string`	`""`	Override auto-detected niche
`price_range`	`string`	`"$19-$29"`	Target price for positioning copy
`product_type`	`string`	`"guide"`	`guide`, `checklist`, `template`, or `toolkit`
`platforms`	`list[str]`	`["twitter", "linkedin", "tiktok", "instagram"]`	Social platforms for distribution
`tone_mode`	`string`	`"conversational"`	`aggressive`, `narrative`, or `conversational`
`min_quality_score`	`float`	`6.0`	Minimum PDF quality score (1-10), triggers retry if below

Output Artifacts

The workflow produces 12+ artifacts:

Artifact	Format	Description
`{title}-v1.pdf`	PDF	Core guide — professionally styled with cover image
`{title}-v2-premium.pdf`	PDF	Premium version with case studies, worksheets, calendar
`{title}-v1.md` / `v2.md`	Markdown	Raw content for further editing
`design-system.json`	JSON	Colors, fonts, layout tokens
`landing-page.html`	HTML	Self-contained, mobile-responsive, SEO-ready landing page
`gumroad-copy.md`	Markdown	Gumroad product page copy with FAQ
`distribution-pack.json`	JSON	20 TikTok hooks, 5 scripts, Twitter thread, Reddit post, captions
`email-sequence.json`	JSON	5-email launch sequence (teaser → launch → proof → value → urgency)
`cover.png`	Image	AI-generated product cover
`social-card-*.png`	Images	Platform-sized social cards with hook overlays

Quality Gate

The V1 content passes through an LLM quality evaluation scoring completeness, actionability, clarity, emotional resonance, and coherence. If the score falls below min_quality_score, the content generation task retries automatically — implementing a “generate → evaluate → regenerate” loop.

Brand Voice Locking

An early lock_brand_voice task defines tone, vocabulary register, sentence style, power words, and words to avoid — based on the detected audience. This voice guide is injected into every downstream content generation prompt, ensuring tonal consistency across the PDF, landing page, emails, and social posts.

Content Series

Workflow: global/content-series

Generates a connected multi-part content series with narrative threading. Each part stands alone but contains forward references (cliffhangers) and backward callbacks, creating anticipation that drives follow/subscribe behavior.

CLI
REST

fab-workflow global/content-series \
  --input topic="why most startups fail at hiring" \
  --input num_parts=3 \
  --input platform=linkedin \
  --input tone_mode=narrative

curl -X POST "$FABRIC_URL/v1/workflows/run?name=global/content-series" \
  -H "Authorization: Bearer $FABRIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "topic": "why most startups fail at hiring",
      "num_parts": 3,
      "platform": "linkedin",
      "tone_mode": "narrative"
    }
  }'

Series Architecture

The system enforces a narrative arc across all parts:

Part 1: SETUP
  Hook hard. Establish the problem.
  End with cliffhanger → "Tomorrow I'll show you what happened when..."

Part 2: COMPLICATION
  Callback → "Yesterday I told you about X. Here's what I didn't mention..."
  Deepen the tension. Introduce twists.
  End with cliffhanger → next part

Part 3: RESOLUTION
  Callback → previous parts
  Deliver the payoff. Insight must feel EARNED.

Each part includes a visual_suggestion for what image or video should accompany it, maintaining visual continuity across the series.

Input

Parameter	Type	Default	Description
`topic`	`string`	required	Overarching topic or theme
`num_parts`	`int`	`3`	Number of parts in the series
`platform`	`string`	`"instagram"`	Primary platform
`tone_mode`	`string`	`"narrative"`	Tone mode
`hook_ideas`	`list[dict]`	`[]`	Pre-generated hooks to weave in
`niche`	`string`	`""`	Content niche
`target_audience`	`string`	`""`	Audience description

Output

{
  "series": [
    {
      "part_number": 1,
      "hook": "We hired 12 people last year. 8 were wrong.",
      "body": "Full post text for Part 1...",
      "overlay_text": "8 WRONG HIRES",
      "visual_suggestion": "Split-screen: empty office chairs vs. packed meeting room",
      "cliffhanger_for_next": "Tomorrow I'll tell you exactly which interview question predicted every bad hire.",
      "callback_to_previous": null,
      "standalone_summary": "Most hiring processes optimize for skills over culture fit, leading to high turnover."
    },
    {
      "part_number": 2,
      "hook": "Yesterday I told you we made 8 bad hires. Here's the question we were afraid to ask.",
      "body": "Full post text for Part 2...",
      "overlay_text": "THE QUESTION",
      "visual_suggestion": "Close-up of interview setting, two chairs facing each other",
      "cliffhanger_for_next": "But knowing the right question wasn't enough. Part 3: the system we built after nearly going under.",
      "callback_to_previous": "Yesterday I told you we made 8 bad hires last year.",
      "standalone_summary": "One interview question predicted culture fit with 85% accuracy."
    }
  ]
}

Ad Sequence

Workflow: global/ad-sequence

Generates a multi-phase retargeting ad sequence with escalating psychological momentum. Unlike generating N independent ads, this produces a temporally sequenced campaign where each phase builds on the previous one.

CLI
REST

fab-workflow global/ad-sequence \
  --input product="AI writing assistant for solopreneurs" \
  --input audience="solopreneurs who write daily but struggle with consistency" \
  --input platforms=instagram,facebook \
  --input sequence_days=7

curl -X POST "$FABRIC_URL/v1/workflows/run?name=global/ad-sequence" \
  -H "Authorization: Bearer $FABRIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "product": "AI writing assistant for solopreneurs",
      "audience": "solopreneurs who write daily but struggle with consistency",
      "platforms": ["instagram", "facebook"],
      "sequence_days": 7
    }
  }'

3-Phase Escalation

Phase	Days	Psychology	Emotional Lever	What NOT to Do
Awareness	1-2	”This brand gets me”	Empathy, recognition	No selling, no product, no discounts
Consideration	3-5	”Maybe this could work”	Trust, social proof	No urgency, no pressure
Conversion	6-7	”I need to act NOW”	Urgency, scarcity	No soft language, be direct

Each phase produces 2 ad variants per platform (A/B testing).

Input

Parameter	Type	Default	Description
`product`	`string`	required	Product/service description
`audience`	`string`	`""`	Target audience
`pain_points`	`list[str]`	`[]`	Audience pain points
`platforms`	`string` or `list`	`["instagram", "facebook"]`	Target platforms
`sequence_days`	`int`	`7`	Campaign duration in days
`tone_mode`	`string`	`"aggressive"`	Tone mode
`unique_value`	`string`	`""`	Product differentiator
`social_proof`	`string`	`""`	Testimonials, stats to reference

Output

{
  "ad_sequence": [
    {
      "phase": 1,
      "phase_name": "Awareness",
      "day_range": "Day 1-2",
      "strategy": "Introduce the writing consistency problem without mentioning the product",
      "ads": [
        {
          "platform": "instagram",
          "variant": "A",
          "headline": "You write every day. But do you publish?",
          "body": "Most solopreneurs have 47 drafts and zero published pieces...",
          "cta": "Learn Why",
          "emotional_lever": "recognition",
          "visual_suggestion": "Split screen: overflowing notes app vs. empty blog"
        }
      ]
    },
    {
      "phase": 2,
      "phase_name": "Consideration",
      "day_range": "Day 3-5",
      "strategy": "Show how the product solved the exact problem from Phase 1",
      "ads": [...]
    },
    {
      "phase": 3,
      "phase_name": "Conversion",
      "day_range": "Day 6-7",
      "strategy": "Time-bound offer with direct CTA and friction removal",
      "ads": [...]
    }
  ]
}

Research-to-Short (Fact-Grounded Video)

Workflow: video/research-to-shorts

Generates a viral short video where every statistic and claim is grounded in real web research. Unlike ai-shorts where the LLM invents freely, this workflow scrapes web sources first and constrains the script to verified facts.

Quick Start

# Minimal — topic only
fab-workflow video/research-to-shorts --input topic="why developers are switching to Rust"

# Full control
fab-workflow video/research-to-shorts \
  --input topic="why developers are switching to Rust" \
  --input mood="informed, slightly opinionated, conversational" \
  --input platform="YouTube" \
  --input max_sources=8 \
  --input duration_secs=60 \
  --input bgm_volume=0.10 \
  --input caption_color="#00FF88"

from fabric_platform import FabricClient

fabric = FabricClient()
run = fabric.run_workflow("video/research-to-shorts", input={
    "topic": "why developers are switching to Rust",
    "mood": "informed, slightly opinionated, conversational",
    "platform": "YouTube",
    "max_sources": 8,
    "duration_secs": 60,
    "bgm_volume": 0.10,
    "caption_color": "#00FF88",
})
result = fabric.wait_for_run(run["id"])
print(result["output"]["final_video_path"])

import { FabricClient } from "@fabric-platform/sdk";
const fabric = new FabricClient();

const run = await fabric.workflows.runs.submitRun({
  workflowSlug: "video/research-to-shorts",
  input: {
    topic: "why developers are switching to Rust",
    mood: "informed, slightly opinionated, conversational",
    platform: "YouTube",
    max_sources: 8,
    duration_secs: 60,
    bgm_volume: 0.10,
    caption_color: "#00FF88",
  },
});
const result = await fabric.workflows.runs.waitForRun(run.id);

Pipeline

web.research (DuckDuckGo scrape, 300-char truncation)
    ↓
ai.generate (fact-grounded script)
    ├── ai.generate (portrait)
    ├── ai.generate (voiceover)
    ├── ai.generate (b-roll × 3)
    └── music.generate (BGM)
            ↓
    talking head → lipsync
    transcribe → subtitles (ASS + SRT)
    audio.mix (ducking)
            ↓
    ffmpeg.composite → video.effects → hook-overlay

Input

Parameter	Type	Default	Description
`topic`	`string`	required	Topic to research and create a video about (also accepts `query`)
`mood`	`string`	`"high-energy and conversational"`	Tone and delivery style
`platform`	`string`	`"TikTok"`	Target platform
`duration_secs`	`int`	`45`	Target video length
`presenter_look`	`string`	`"confident young creator..."`	AI actor appearance description
`visual_style`	`string`	`""`	Override visual aesthetic (e.g. “neon cyberpunk”)
`quality`	`string`	`""`	Quality preset: `cheap`, `premium`, `ultra`, `local`
`bgm_volume`	`float`	`0.15`	Background music volume (0.0–1.0)
`num_hooks`	`int`	`15`	Number of hooks to generate before selecting the best

Anti-Hallucination Design

The web.research node scrapes web sources and truncates each snippet to 300 characters. This serves two purposes:

Factual grounding — the script generation prompt includes "Every statistic MUST come from the verified facts above", constraining the LLM to real data
Prompt injection defense — truncation limits the attack surface from scraped web content

The script output includes a fact_sources field listing which URLs were used, enabling source attribution.

Output

The pipeline produces a single .mp4 file at 1080x1920 (9:16 vertical) with burned-in subtitles, hook text overlay, and mixed audio. An SRT sidecar file is also generated for platform-native captions.

vs. ai-shorts

	ai-shorts	research-to-short
Script grounding	LLM invents freely	Web research with attribution
Hallucination risk	High	Low
Caption formats	ASS + SRT	ASS + SRT
Caption styling	Parameterized	Parameterized
Color grading	Yes	Yes

Content Modification

Workflow: global/content-modify

Takes existing content (text, image, audio, or video) and a natural-language prompt, then rewrites or redesigns the content accordingly. Supports preservation constraints to keep specific aspects unchanged.

# Rewrite text content
fab-workflow global/content-modify \
  --input content="Your blog post text here..." \
  --input prompt="Make it more casual and add humor" \
  --input preserve='["key_points", "length"]'

# Modify an image
fab-workflow global/content-modify \
  --input content=photo.jpg \
  --input prompt="Add dramatic lighting and warmer tones" \
  --input content_type=image

# Adjust audio
fab-workflow global/content-modify \
  --input content=voiceover.mp3 \
  --input prompt="Speed it up 1.5x"

# Edit video
fab-workflow global/content-modify \
  --input content=video.mp4 \
  --input prompt="Cut the first 10 seconds"

curl -X POST "$FABRIC_URL/v1/workflows/run?name=global/content-modify" \
  -H "Authorization: Bearer $FABRIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "content": "Your blog post text here...",
      "prompt": "Make it more casual and add humor",
      "preserve": ["key_points", "length"]
    }
  }'

from fabric_platform import FabricClient

fabric = FabricClient()
run = fabric.run_workflow("global/content-modify", input={
    "content": "Your existing blog post...",
    "prompt": "Rewrite for a developer audience, add code examples",
    "preserve": ["structure"],
})
result = fabric.wait_for_run(run["id"])
print(result["output"]["modified_content"])

Pipeline

analyze_content → apply_modifications → evaluate_and_refine

Content type is auto-detected from the input (inline text vs. file extension), or can be overridden with content_type.

Content Types

Type	Input Format	Modification Capabilities
`text`	Inline text string	Full LLM rewrite with tone, style, structure changes
`image`	File path or URL (`.jpg`, `.png`, etc.)	Vision analysis → regeneration with modifications
`audio`	File path or URL (`.mp3`, `.wav`, etc.)	Speed, trim, re-voice with modified script
`video`	File path or URL (`.mp4`, `.mov`, etc.)	Trim, speed, filters via ffmpeg

Preservation Constraints

The preserve parameter accepts a list of aspects to keep unchanged:

Constraint	Effect
`tone`	Keep the same writing tone/voice
`length`	Maintain approximate word count
`structure`	Keep the same organizational structure
`style`	Preserve formatting and stylistic choices
`key_points`	Keep the same core arguments/ideas

Self-Evaluation Loop

For text content, the workflow evaluates the modification against the original prompt and scores fidelity, quality, and preservation compliance. If the score falls below 7/10, it automatically refines (up to 2 additional passes).

Input

Parameter	Type	Default	Description
`content`	`string`	required	The content to modify (inline text or file path/URL)
`prompt`	`string`	required	Modification instructions
`content_type`	`string`	auto-detected	`"text"`, `"image"`, `"audio"`, or `"video"`
`preserve`	`list[str]`	`[]`	Aspects to keep unchanged

Output

{
  "content_type": "text",
  "original_summary": "Blog post about remote work productivity...",
  "modified_content": "The full rewritten text...",
  "modifications_applied": [
    "Shifted tone from formal to conversational",
    "Added humor through self-deprecating observations",
    "Replaced jargon with plain language"
  ],
  "fidelity_score": 8.5
}

Content Generation

Workflow: content/generate

Analyzes a topic, generates structured content (blog posts, articles, emails), and evaluates quality.

CLI
REST

fab-workflow content/generate \
  --input topic="The future of remote work" \
  --input content_type="blog post" \
  --input audience="tech professionals"

curl -X POST "$FABRIC_URL/v1/workflows/run?name=content/generate" \
  -H "Authorization: Bearer $FABRIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "topic": "The future of remote work",
      "content_type": "blog post",
      "audience": "tech professionals"
    }
  }'

Pipeline

analyze_topic → generate_content → evaluate_quality

Input

Parameter	Type	Default	Description
`topic`	`string`	required	Content topic
`audience`	`string`	`""`	Target audience
`content_type`	`string`	`"blog post"`	Format: `blog post`, `email`, `social`, `video script`

Output

{
  "generated_content": {
    "title": "...",
    "content": "Full article text...",
    "meta_description": "...",
    "tags": ["remote-work", "productivity"]
  },
  "evaluation": {
    "overall_score": 8.5,
    "scores": {"clarity": 9, "engagement": 8, "seo": 7, "originality": 9, "actionability": 8},
    "improvements": ["Add more specific data points"],
    "ready_to_publish": true
  }
}

Long-Form Script

Workflow: content/long-form-script

Elite long-form scriptwriting with 6 narrative archetypes. Generates multi-act scripts with retention hooks, pacing guidance, and tone direction.

CLI
REST

fab-workflow content/long-form-script \
  --input topic="The hidden cost of technical debt" \
  --input archetype="documentary" \
  --input duration_minutes=10

fab-workflow content/long-form-script \
  --input topic="How one developer built a $10M SaaS" \
  --input archetype="hero_journey"

curl -X POST "$FABRIC_URL/v1/workflows/run?name=content/long-form-script" \
  -H "Authorization: Bearer $FABRIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "topic": "The hidden cost of technical debt",
      "archetype": "documentary",
      "duration_minutes": 10
    }
  }'

Archetypes

Archetype	Structure	Best For
`documentary`	Setup → evidence → synthesis → implications	Analytical, research-heavy topics
`hero_journey`	Origin → challenge → transformation → lesson	Personal or founder stories
`true_crime`	Mystery → investigation → revelation → aftermath	Investigative, expose-style content
`listicle`	Hook → items with escalation → callback	Ranked or numbered content
`problem_solution`	Problem → failed attempts → solution → proof	Tutorial and how-to content
`explainer`	Question → context → mechanism → so-what	Educational deep-dives

Pipeline

research_topic → select_structure → generate_acts → score_retention

Input

Parameter	Type	Default	Description
`topic`	`string`	required	Script topic
`archetype`	`string`	auto-selected	Narrative archetype
`duration_minutes`	`int`	`8`	Target video length
`mood`	`string`	`""`	Tone direction

Build in Public

Workflow: global/build-in-public

Transforms GitHub repo activity into authentic “build in public” social media posts. Fetches README, releases, and recent commits via GitHub API, extracts compelling story angles using 8 archetypes, and generates platform-native posts with a quality gate.

CLI
REST

fab-workflow global/build-in-public \
  --input repo_url="https://github.com/astral-sh/ruff"

fab-workflow global/build-in-public \
  --input repo_url="https://github.com/astral-sh/ruff" \
  --input author_name="Charlie" \
  --input author_context="building a Python linter in Rust" \
  --input platforms="twitter,linkedin,threads" \
  --input time_range_days=14 \
  --input num_posts=5

curl -X POST "$FABRIC_URL/v1/workflows/run?name=global/build-in-public" \
  -H "Authorization: Bearer $FABRIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "repo_url": "https://github.com/astral-sh/ruff",
      "author_name": "Charlie",
      "author_context": "building a Python linter in Rust",
      "platforms": "twitter,linkedin,threads",
      "time_range_days": 14,
      "num_posts": 5
    }
  }'

Story Archetypes

Archetype	Signal Patterns	Voice Example
`progress_update`	Multiple `feat:` commits, new release	”Shipped X this week. Here’s why it matters…”
`til_moment`	Refactors, dependency changes, perf improvements	”TIL: I always assumed X but turns out Y…”
`milestone`	Version bump, v1.0/v2.0 release	”Just hit [milestone]. Started this [timeframe] ago…”
`behind_the_scenes`	Architecture changes, new modules	”Everyone asks how we handle X. Here’s the actual architecture…”
`struggle_win`	Fix sequences, reverts then re-implements	”Spent 3 days on X. The fix? One line…”
`before_after`	Large refactors, delete-heavy commits	”Before: [old way]. After: [new way]…”
`hot_take`	Unconventional tech choices	”Unpopular opinion: [decision]. Here’s why…”
`lessons_learned`	Reverts, major refactors, deprecations	”If I could start over, I’d change [thing]…”

Pipeline

validate_input → fork(fetch_readme, fetch_releases, fetch_commits) →
merge_github_data → extract_story_angles → generate_posts →
quality_gate → format_output

Input

Parameter	Type	Default	Description
`repo_url`	`string`	required	GitHub repository URL
`platforms`	`string`	`"twitter,linkedin,threads,tiktok,youtube"`	Target platforms (comma-separated)
`voice`	`string`	`"conversational"`	Writing voice
`github_token`	`string`	env	GitHub API token (higher rate limits)
`time_range_days`	`int`	`30`	How far back to look at commits
`num_posts`	`int`	`5`	Number of posts to generate
`author_name`	`string`	`""`	Author name for personal touch
`author_context`	`string`	`""`	What the author is building

URL to Assets

Workflow: global/url-to-assets

Scrapes any URL (article, blog, GitHub repo, YouTube video, Reddit post) and generates multiple content asset types: social posts, video scripts, hook variants, and captions.

CLI
REST

fab-workflow global/url-to-assets \
  --input url="https://example.com/article" \
  --input platforms=instagram,twitter

fab-workflow global/url-to-assets \
  --input url="https://youtube.com/watch?v=..." \
  --input asset_types=script,hooks,posts

curl -X POST "$FABRIC_URL/v1/workflows/run?name=global/url-to-assets" \
  -H "Authorization: Bearer $FABRIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "url": "https://example.com/article",
      "platforms": ["instagram", "twitter"],
      "asset_types": ["posts", "hooks", "script"]
    }
  }'

Pipeline

scrape_url → extract_content_angles → generate_assets

Auto-detects content type from URL patterns:

URL Pattern	Detected Type
`youtube.com/watch`, `youtu.be/`	YouTube (extracts transcript + metadata)
`github.com/`	GitHub repo
`twitter.com/`, `x.com/`	Twitter/X
`reddit.com/`	Reddit post
Everything else	Article (HTML readability extraction)

Input

Parameter	Type	Default	Description
`url`	`string`	required	URL to scrape
`platforms`	`string` or `list`	`["instagram", "twitter"]`	Target platforms for generated assets
`asset_types`	`string` or `list`	`["posts", "hooks", "script"]`	Types of assets to generate

Formula Extraction

Workflow: global/formula-extract

Analyzes reference videos to extract reusable style DNA as a VideoFormula. Extracts keyframes, probes media metadata, transcribes audio, then runs 4 parallel analysis branches (visuals, audio, script, effects) using Gemini vision. When given multiple videos, synthesizes a consensus formula.

CLI
REST

# Single video
fab-workflow global/formula-extract \
  --input url="https://youtube.com/watch?v=..." \
  -o output/formula.json

# Multiple videos (consensus extraction)
fab-workflow global/formula-extract \
  --input 'urls=["https://youtube.com/watch?v=...", "https://tiktok.com/@user/video/..."]' \
  -o output/formula.json

# Single video
curl -X POST "$FABRIC_URL/v1/workflows/run?name=global/formula-extract" \
  -H "Authorization: Bearer $FABRIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "url": "https://youtube.com/watch?v=..."
    }
  }'

# Multiple videos
curl -X POST "$FABRIC_URL/v1/workflows/run?name=global/formula-extract" \
  -H "Authorization: Bearer $FABRIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "urls": [
        "https://youtube.com/watch?v=...",
        "https://tiktok.com/@user/video/..."
      ]
    }
  }'

Pipeline

download_media → probe_media → transcribe →
fork(analyze_visuals, analyze_audio, analyze_script, analyze_effects) →
merge_analysis → synthesize_formula

For multiple videos, the single_video_analysis sub-pipeline runs per video, then results are merged into a consensus formula.

Output

The formula JSON captures every dimension of video style:

Section	Contents
`script`	Hook type, tone, emotional trigger, CTA style, word choice patterns, segment structure
`visuals`	Overall aesthetic, camera work, lighting, color palette, film stock match
`audio`	Voice (gender, style), music (mood, volume level)
`effects`	Subtitle colors/position/size, color grade (FFmpeg hints), hook overlay style

Use the output with Formula Shorts to generate new videos in the extracted style.