Blog Post

Blog Post — Full-Stack Content Production

Turn a topic into a complete, strategy-aware publishing package: long-form post + social adaptations + multimedia assets.

Compounding Skills

This skill orchestrates — it does not re-implement what already exists:

Rule: Before generating content for any phase, check if a compounding skill handles it better. Delegate, don't duplicate.

Modes

Full Pipeline (default)

BRIEF → RESEARCH → ANGLE → OUTLINE → LONG-FORM → ADAPT → MEDIA → STRATEGY → PUBLISH

9 phases, each produces a file or action in the output package.

X-First Mode

BRIEF → ANGLE → X CONTENT → MEDIA → PUBLISH

Lightweight mode for standalone X content — not derived from a blog post. Use when: building in public, reacting to news, sharing a demo, shipping a contrarian take, or posting a terminal screenshot with context. Produces x-post.md and/or x-thread.md with growth-optimized patterns. See references/x-growth-strategy.md.

Triggers: "x post about", "tweet about", "x thread about", "post on x", "ship to x", "build in public"

X-First pipeline: 1. Brief — Topic + intent (1 line is enough) 2. Angle — Apply the angle test (specificity, tension, evidence) even for short content 3. Generate — Use growth-optimized templates: visual proof, native media, engagement hooks, strategic tags 4. Media — Terminal screenshot, architecture diagram, demo GIF, or native video (60-90s) 5. Publish — Via xurl post or xurl reply (thread). Always attach media natively (never external links)

X-First content types (see references/x-growth-strategy.md):

• Terminal screenshot + insight (3-5x/week)
• "How I built X" thread (1x/week)
• Demo video, 60-90s native (1x/week)
• Contrarian take (1-2x/week)
• Before/after comparison (1-2x/week)
• "Day N of building X" update (daily optional)
• Strategic reply to big accounts (3-5x/day)

Phase 0: Content Brief Intake

Gather or construct a content brief. See templates/brief.md for the template.

Required fields:

• topic — What this post is about
• intent — Why this post exists (educate, persuade, announce, reflect, document)
• audience — Who reads this (developers, founders, general, specific community)

Optional fields:

• platforms — Target channels (default: all). Options: broomva-tech, substack, x-post, x-thread, linkedin, instagram-post, instagram-reel
• tone — Voice (default: confident-technical). Options: conversational, academic, provocative, reflective, storytelling
• references — URLs, papers, prior posts to build on
• media — Desired outputs: png, mp4, gif, mp3 (default: all)
• cta — What should the reader do after? (follow, subscribe, try, share, discuss)
• destination — Primary long-form target (default: broomva-tech). Options: substack, medium, dev-to, hashnode
• slug — URL-friendly identifier (auto-generated from topic if omitted)

If the user provides only a topic, infer reasonable defaults and confirm before proceeding.

Phase 1: Research & Enrichment

When to research: If the brief includes references, data claims, or the topic requires external validation.

How to research: 1. Use /deep-research for topics needing 5+ verified sources 2. Use /agent-browser to extract content from reference URLs 3. Use web search for current data, trends, or competitor context 4. Use /competitor-intel if topic involves market positioning

Output: research.md — key findings, sources, data points, quotes. Keep it factual and citable.

When to skip: Personal reflections, opinion pieces, internal documentation — research is optional, not mandatory.

Phase 2: Angle & Narrative Selection

The angle is what makes content intentional rather than generic. It answers: "Of all the things I could say about this topic, what specific lens am I using and why?"

Angle selection criteria: 1. Audience gap — What does this audience need that isn't being said? 2. Unique evidence — What data or experience do I have that others don't? 3. Contrarian potential — Is there a widely-held belief I can challenge with evidence? 4. Timeliness — Is there a current event or trend that makes this relevant now? 5. Story potential — Is there a transformation narrative (before → after)?

Framework selection (from /content-creation storytelling references):

Output: Update outline.md with the chosen angle, framework, and rationale.

Phase 3: Outline Generation

Build a structured outline from the angle. This is the architectural blueprint — all downstream content derives from it.

Outline structure:

# Title Options (3 candidates, pick best)

## Hook (1-2 sentences — the "why should I care" opener)

## Sections
1. [Section name] — [1-line purpose]
   - Key point A
   - Key point B
   - Evidence/data to include
   - Media placement: [image/video/gif opportunity]

2. [Section name] — [1-line purpose]
   ...

## Closing
- Memorable takeaway (one line)
- CTA alignment with brief

## Media Inventory
- Hero image concept
- Supporting images (one per ~300 words)
- Video opportunity (if applicable)
- GIF opportunity (if applicable)
- Audio narration (y/n)

Output: outline.md

Phase 4: Long-Form Content Generation

Write the primary long-form post. Target platform determines format.

broomva.tech (default)

Use the templates/broomva-tech-post.mdx template.

Frontmatter schema:

---
title: "Post Title"
summary: "One-sentence summary for cards and SEO"
date: YYYY-MM-DD
published: true
tags:
  - tag1
  - tag2
audio: /audio/writing/{slug}.mp3  # if audio generated
---

Content conventions:

• Use standard Markdown (GFM) — the engine renders via remark + remark-gfm
• Embed video: <video src="/images/writing/{slug}/video.mp4" autoplay muted loop playsinline style="width:100%;border-radius:8px;margin-bottom:1.5rem"></video>
• Images: ![Alt text](/images/writing/{slug}/image-name-opt.png)
• Figures: <figure><img src="..." alt="..." /><figcaption>Caption</figcaption></figure>
• Tables: Standard GFM tables (styled by Tailwind prose)
• No custom MDX components needed — raw HTML works

Substack / Alternative Platforms

Use templates/substack-post.md. Standard Markdown, no frontmatter beyond title/subtitle. Adjust image paths to be relative or hosted URLs.

Output: broomva-tech-post.mdx and/or substack-post.md (based on destination in brief)

Phase 5: Cross-Platform Adaptation

Critical rule: Each platform gets native content, not a copy-paste resize. The core message is shared; the expression is platform-native.

Adaptation Matrix

Platform-Specific Content Generation

See references/platform-adaptation.md for detailed per-platform strategies.

X Blog Post — Full long-form article published directly on X (formerly "Twitter Articles"). Freeform length — can match or exceed the broomva.tech post. Supports inline images, videos, GIFs, and rich formatting. Unlike the broomva.tech post, the X blog post is written for X's audience and algorithm — more conversational, more opinionated, more multimedia-dense. Every section should be accompanied by a visual (image, diagram, GIF, or video clip). The hero image is critical — it's the thumbnail that determines clicks. Use Imagen 4.0 for hero + supporting images, Veo 3.1 clips for inline video, and ffmpeg GIFs for demos. See references/x-blog-post.md.

X Post — Extract the single most surprising or provocative insight. Always attach an image (terminal screenshot, diagram, before/after, or generated visual) — text-only posts get 60% less reach. No external links in post body (X suppresses them) — put links in a self-reply. Include an engagement hook: question, contrarian frame, or "reply with your experience." Tag 1-2 relevant accounts when genuinely building on their work. See references/x-growth-strategy.md.

X Thread — Re-tell the story in tweet-sized beats. Each tweet stands alone while building momentum. Spend 50% of effort on tweet 1 — it determines everything. Image every 2-3 tweets (increases completion by 45%). Self-reply the full chain fast (don't trickle). End with CTA: question for replies, Discord invite, or link in final self-reply. Tag the most relevant account in tweet 1 if crediting their work. See references/x-growth-strategy.md.

LinkedIn — Professional framing. Lead with insight or contrarian take in first 210 chars (before "See More" fold). Use bullet lists for key takeaways. 3-5 hashtags max.

Instagram Post — Design a carousel: cover slide with hook, 1 insight per slide (flashcard style, not paragraphs), stat slide, CTA slide. Caption tells the story; slides show the highlights.

Instagram Reel — Write a script with: 3-second visual hook, problem statement (5s), key insight (10-15s), evidence or demo (10-15s), CTA (5s). Vertical 9:16 format. See references/reel-production.md for Veo 3.1 prompting and subtitle burn-in.

Output: x-blog-post.md, x-post.md, x-thread.md, linkedin-post.md, instagram-post.md, instagram-reel.md

Phase 6: Multimedia Production

Plan and produce media assets. See references/multimedia-production.md.

Asset Types

Media Prompt Generation

For each planned asset, generate a specific AI prompt in media/image-prompts.md:

• Describe the visual concept tied to the content it accompanies
• Include style direction (dark theme, technical, minimal, etc.)
• Specify dimensions and aspect ratio per platform

Audio Script

If audio is targeted, extract the post body text and write a narration-ready script in media/audio-script.md. Strip markdown formatting, add natural pauses, and note pronunciation guides for technical terms.

Video Script

If video is targeted, write a Remotion-compatible composition outline in media/video-script.md:

• Scene breakdown (title, stats, screenshots, workflow, closing)
• Duration per scene
• Transition style
• Asset references (which images/clips to use)

Output: media/ directory with prompt files and any generated assets

Phase 7: Strategy & Distribution Planning

Generate strategy documents for the content package.

Output files in `strategy/`:

• audience.md — Target audience profile, what they care about, where they are
• platform-strategy.md — Per-platform approach, posting time, format rationale
• distribution-plan.md — Publishing sequence (which platform first, timing gaps, cross-linking)
• cta.md — Call-to-action strategy aligned across all channels

Distribution Sequencing

Recommended order (adjust per strategy): 1. Blog post first (canonical URL) 2. X thread within 1 hour (drives initial engagement) 3. LinkedIn same day (professional audience, different peak hours) 4. Instagram carousel next day (visual audience, different consumption pattern) 5. Instagram reel 2-3 days later (extends content lifecycle) 6. X post (standalone) as engagement trigger mid-week

Phase 8: Publishing & Distribution

Execute the distribution plan by publishing content to each platform. Uses CLI tools and REST APIs — no third-party services.

Platform Connectors

X Publishing (via xurl)

Prerequisite check: xurl whoami — if 401, prompt user to run xurl auth oauth2.

Single post:

# Text only
xurl post "$(cat x-post.md | head -1)"

# With image
xurl post "$(cat x-post.md | head -1)" --media media/thumbnails/x-card.png

Thread (parse x-thread.md, post sequentially):

# Extract tweet 1 (the hook), post it, capture the tweet ID
FIRST_ID=$(xurl post "Tweet 1 text" --media media/png/hero.png 2>&1 | jq -r '.data.id')

# Reply chain for remaining tweets
xurl reply $FIRST_ID "Tweet 2 text"
# ... continue for each tweet

Thread parsing logic: Read x-thread.md, split on ### N/N headers, extract text between headers, identify 📸 Image: lines for media attachment. See references/publishing-automation.md.

LinkedIn Publishing (via curl)

Prerequisite: OAuth2 access token stored in ~/.config/blog-post/linkedin-token.

LINKEDIN_TOKEN=$(cat ~/.config/blog-post/linkedin-token)
LINKEDIN_URN=$(cat ~/.config/blog-post/linkedin-urn)

# Uses Posts API v2 (ugcPosts was deprecated in 2024)
curl -s -X POST "https://api.linkedin.com/v2/posts" \
  -H "Authorization: Bearer $LINKEDIN_TOKEN" \
  -H "Content-Type: application/json" \
  -H "LinkedIn-Version: 202401" \
  -H "X-Restli-Protocol-Version: 2.0.0" \
  -d "{
    \"author\": \"urn:li:person:$LINKEDIN_URN\",
    \"commentary\": \"$(cat linkedin-post.md | sed '1,2d' | head -40)\",
    \"visibility\": \"PUBLIC\",
    \"distribution\": { \"feedDistribution\": \"MAIN_FEED\" },
    \"lifecycleState\": \"PUBLISHED\"
  }"

Instagram Publishing (via Meta Graph API)

Prerequisite: Business/Creator account, access token in ~/.config/blog-post/instagram-token.

IG_TOKEN=$(cat ~/.config/blog-post/instagram-token)
IG_USER_ID=$(cat ~/.config/blog-post/instagram-user-id)

# Step 1: Create media container (image must be publicly hosted)
CONTAINER_ID=$(curl -s -X POST \
  "https://graph.instagram.com/v19.0/$IG_USER_ID/media" \
  -d "image_url=https://broomva.tech/images/writing/{slug}/hero.png" \
  -d "caption=$(cat instagram-post.md | sed -n '/^## Caption/,$ p' | tail -n+2)" \
  -d "access_token=$IG_TOKEN" | jq -r '.id')

# Step 2: Publish
curl -s -X POST \
  "https://graph.instagram.com/v19.0/$IG_USER_ID/media_publish" \
  -d "creation_id=$CONTAINER_ID" \
  -d "access_token=$IG_TOKEN"

broomva.tech Publishing

SLUG="{slug}"
# Copy post and assets
cp broomva-tech-post.mdx ~/broomva/broomva.tech/apps/chat/content/writing/$SLUG.mdx
mkdir -p ~/broomva/broomva.tech/apps/chat/public/images/writing/$SLUG/
cp media/png/* ~/broomva/broomva.tech/apps/chat/public/images/writing/$SLUG/
# Copy audio if exists
[ -f media/mp3/narration.mp3 ] && \
  cp media/mp3/narration.mp3 ~/broomva/broomva.tech/apps/chat/public/audio/writing/$SLUG.mp3
# Create PR
cd ~/broomva/broomva.tech
git checkout -b content/$SLUG
git add apps/chat/content/writing/$SLUG.mdx apps/chat/public/images/writing/$SLUG/
git commit -m "content: add $SLUG"
git push -u origin content/$SLUG
gh pr create --title "content: $SLUG" --body "New blog post"

Publishing Workflow

When the user says "publish" or "distribute" after a content package is ready:

1. Check available connectors — Run xurl whoami, check for LinkedIn/IG tokens 2. Report what can be published — List platforms with ✅ (ready) or ❌ (needs setup) 3. Confirm with user — Show what will be posted to each platform, ask for go-ahead 4. Execute in sequence — Follow the distribution plan order 5. Report results — Show post URLs/IDs for each platform, note any failures 6. Update README.md — Mark published platforms with URLs

Credential Storage

Store platform tokens in ~/.config/blog-post/ (gitignored, never committed):

~/.config/blog-post/
├── linkedin-token       # LinkedIn OAuth2 access token
├── linkedin-urn         # LinkedIn member URN
├── instagram-token      # Meta/Instagram access token
└── instagram-user-id    # Instagram Business account ID

X credentials are managed by xurl internally (stored in its own keychain).

Graceful Degradation

• No xurl auth? → Generate post text but skip publishing; show xurl auth oauth2 instructions
• No LinkedIn token? → Generate post but skip; show OAuth setup steps
• No Instagram token? → Generate post but skip; show Meta app setup steps
• Always confirm before posting — Never auto-publish without explicit user approval

Output Structure

Each invocation creates a package at /broomva/posts/{YYYY-MM-DD}-{slug}/:

{YYYY-MM-DD}-{slug}/
├── README.md                    # Package manifest (what's inside, status, links)
├── brief.md                     # Content brief (input)
├── research.md                  # Research notes (if applicable)
├── outline.md                   # Content outline with angle + framework
├── broomva-tech-post.mdx        # Primary long-form (broomva.tech)
├── substack-post.md             # Alternative long-form (if requested)
├── x-blog-post.md               # X long-form article (multimedia-rich)
├── x-post.md                    # X single post
├── x-thread.md                  # X thread (5-8 tweets)
├── linkedin-post.md             # LinkedIn post
├── instagram-post.md            # Instagram caption + carousel spec
├── instagram-reel.md            # Reel script/concept
├── media/
│   ├── image-prompts.md         # AI image generation prompts
│   ├── audio-script.md          # TTS narration script
│   ├── video-script.md          # Video composition script
│   ├── gif-concept.md           # GIF animation concept
│   ├── hero.png                 # Hero/social card (generated)
│   ├── thumbnails/              # Per-platform thumbnails
│   ├── png/                     # Static images
│   ├── gif/                     # Animated GIFs
│   ├── mp3/                     # Audio narration
│   └── mp4/                     # Video files
└── strategy/
    ├── audience.md              # Target audience profile
    ├── platform-strategy.md     # Per-platform approach
    ├── distribution-plan.md     # Publishing schedule + sequence
    └── cta.md                   # Call-to-action strategy

Agent Behavior

On Invocation

1. Parse intent — Extract topic, audience, intent from user message 2. Check brief completeness — If only topic provided, propose defaults and confirm 3. Create output directory — mkdir -p /broomva/posts/{date}-{slug}/media/{thumbnails,png,gif,mp3,mp4} /broomva/posts/{date}-{slug}/strategy 4. Execute phases 0-7 sequentially — Each phase produces its output file 5. Generate media assets — Use available tools (Nano Banana, ffmpeg, kokoro-tts). If tools unavailable, leave prompt files for manual generation 6. Copy to broomva.tech — If destination is broomva-tech, also copy .mdx to broomva.tech/apps/chat/content/writing/{slug}.mdx and images to broomva.tech/apps/chat/public/images/writing/{slug}/ 7. Publish (Phase 8) — If user says "publish" or "distribute", execute the distribution plan via xurl (X), curl (LinkedIn/Instagram), and git (broomva.tech). Always confirm before posting. 8. Report — Summarize what was created, what was published (with URLs), what needs manual action

Graceful Degradation

• No GEMINI_API_KEY? → Generate image prompts but skip generation; note in README
• No ffmpeg/Remotion? → Write video/GIF scripts but skip rendering; note in README
• No TTS engine? → Write audio script but skip narration; note in README
• Never fail silently — Always explain what was skipped and why

Quality Gates

Before completing, validate:

• [ ] Every platform adaptation has a unique hook (not copy-pasted)
• [ ] Long-form post has at least 3 media placement points
• [ ] X thread has 5-8 tweets with images planned every 2-3 tweets
• [ ] Instagram carousel has cover + 8-12 content slides specified
• [ ] LinkedIn hook is ≤ 210 characters
• [ ] CTA is consistent across channels but adapted per platform
• [ ] All file paths in README match actual files created
• [ ] No placeholder text remains in any output file

See references/quality-checklist.md for the full validation checklist.

Reel Production Quality Gates

When producing Instagram Reels (via Veo 3.1 + ffmpeg):

• [ ] Hook grabs attention in first 3 seconds (visual movement, NOT just text)
• [ ] Subtitles burned in (80% watch muted)
• [ ] No static shot longer than 5 seconds
• [ ] Audio present (narration, ambient, or music — never silence)
• [ ] CTA in final 3 seconds
• [ ] 9:16 vertical, -movflags +faststart
• [ ] Duration 15-45 seconds

See references/reel-production.md for Veo 3.1 prompting (5-part formula, camera vocabulary), subtitle generation, and the full production pipeline.

Self-Evolution

This skill improves with every use. See references/self-evolution.md for the full protocol.

After every publish: Track which hooks, formats, and timings performed best. Promote winners to templates. Annotate losers.

Feedback loop: PUBLISH → MEASURE (48h) → EXTRACT PATTERNS → UPDATE SKILL → NEXT PUBLISH

X growth tracking: Track followers/week, impressions/post, thread completion rate, engagement rate, and reply engagement from watchlist accounts. See references/x-growth-strategy.md for full metrics.

Content pillars: Build Logs, Agent Architecture, Meta-Content, Open Source, Contrarian Takes. Each pillar has an optimal platform mix and X-first format.

Compounding: New skills are integrated when they handle a task the pipeline currently does manually, have 100+ community installs, and don't bloat SKILL.md beyond 600 lines.

Quick Start

User: /blog-post "Building an Agent OS in Rust" — targeting developers,
      intent is to educate and attract contributors, provocative tone

Agent: [Creates brief → researches if needed → selects ABT angle →
       outlines → writes long-form → adapts for X/LinkedIn/IG →
       generates media + reels via Veo 3.1 → publishes via xurl/curl/git]

Content Brief

Core

• Topic: Building an Agent OS in Rust — why Rust, how the architecture works, and what it means for autonomous AI
• Intent: educate + attract contributors
• Audience: Systems engineers, Rust developers, AI infrastructure builders
• Angle: While most AI agent frameworks are Python scripts with LLM wrappers, we built a full operating system in Rust — with event-sourced persistence, homeostatic regulation, and real financial agency — because agents deserve the same rigor as the systems they control.

Configuration

• Destination: broomva-tech
• Tone: provocative + confident-technical
• Slug: agent-os-launch

Platforms

• [x] broomva-tech
• [x] X post
• [x] X thread
• [x] LinkedIn
• [x] Instagram post (carousel)
• [x] Instagram reel

Media Targets

• [x] PNG (hero + architecture diagram + layer breakdown)
• [x] MP3 (audio narration)
• [x] MP4 (30s stack walkthrough video)
• [x] GIF (architecture animation)

References

• https://github.com/broomva/life
• Prior post: a-letter-from-the-machine.mdx
• Rust performance benchmarks vs Python agent frameworks

Call to Action

• Primary CTA: Star the repo and explore the codebase
• Secondary: Follow for updates on the Agent OS journey

Instagram Post

Carousel Slides (1080×1350px, 4:5 ratio)

Slide 1 — Cover

Text: "We Built an OS for AI Agents" Design: Dark background, AI Blue (#3B82F6) accent, Arcan Glass styling, bold sans-serif

Slide 2 — Problem

Text: "Most agent frameworks are Python scripts calling an LLM in a loop. They crash. They forget. They can't manage money." Visual: Broken loop icon, red warning indicators

Slide 3 — The Question

Text: "What if agents had real infrastructure?" Visual: Clean, centered text on dark background

Slide 4 — Architecture

Text: "7 subsystems. One operating system." Visual: Layered architecture diagram showing all 7 crates

Slide 5 — Memory

Text: "Event-sourced persistence: every decision is an immutable journal entry" Visual: Append-only log visualization

Slide 6 — Stability

Text: "Homeostatic regulation: 3-pillar control (operational, cognitive, economic)" Visual: Three gauge meters with green zones

Slide 7 — Finance

Text: "Real financial agency: agents earn, spend, and manage budgets via x402" Visual: Payment flow diagram

Slide 8 — Key Stat

Text: "15,000 lines of Rust. 7 crates. Open source." Visual: Large typography, minimal background

Slide 9 — CTA

Text: "Save this. Star the repo. Build with us." Visual: GitHub star button, profile reference

Caption

An operating system for AI agents — built from scratch in Rust.

Not another Python wrapper. A full OS with event-sourced memory, homeostatic self-regulation, real financial agency, and distributed networking.

The thing most agent frameworks get wrong: they treat infrastructure as an afterthought. But an agent that can't remember, can't manage its budget, and crashes under load isn't autonomous — it's a demo.

We built the infrastructure layer that makes real autonomy possible. And it's all open source.

Link in bio for the full architecture deep dive.

. . . #AgentOS #RustLang #AIAgents #OpenSource #MachineLearning #AIInfrastructure #SystemsProgramming #AutonomousAgents #DevTools #BuildInPublic #TechArchitecture #AIEngineering #EventSourcing #DistributedSystems #WebAssembly #AgentFramework #AIStartup #DeveloperTools #SoftwareArchitecture #Innovation

Post Metadata

• Slide count: 9
• Design tool: /pencil MCP with Arcan Glass styling
• Posting time: Day 2, 11 AM ET
• Alt text per slide: yes

Instagram Reel

Script (30 seconds, 9:16 vertical, 1080×1920px)

[0-3s] — HOOK

Visual: Fast zoom into a terminal showing Rust compilation, then cut to architecture diagram Audio/VO: "We built an entire operating system for AI agents." Captions: "We built an OS for AI agents 🤖"

[3-8s] — PROBLEM

Visual: Split screen — left: Python traceback / right: "agent crashed" notification Audio/VO: "Most agent frameworks are just Python scripts calling an LLM in a loop. They crash. They forget. They can't manage money." Captions: "Most frameworks crash, forget, can't budget"

[8-18s] — INSIGHT

Visual: Animated architecture diagram revealing 7 layers one by one (Remotion spring animation) Audio/VO: "So we built a real one. Seven subsystems: runtime, memory, homeostasis, finance, tools, observability, networking. All in Rust." Captions: "7 subsystems. All Rust. All open source." B-roll: Layer-by-layer reveal animation (Veo 3.1 or Remotion)

[18-24s] — EVIDENCE

Visual: Terminal showing agent loop running — event journal scrolling, metrics dashboard Audio/VO: "Fifteen thousand lines of Rust. Event-sourced persistence. Homeostatic regulation. Real payments." Captions: "15K lines of Rust. Production-ready."

[24-28s] — TAKEAWAY

Visual: GitHub repo page, star count Audio/VO: "Agents deserve the same infrastructure rigor as the systems they control." Captions: "Agents deserve real infrastructure"

[28-30s] — CTA

Visual: "github.com/broomva/life" in large text, follow button Audio/VO: "Link in bio. Star the repo." Captions: "⭐ Link in bio"

Production Notes

• Total duration: 30s
• Aspect ratio: 9:16 (1080×1920)
• Captions: On-screen throughout (white text, dark semi-transparent background)
• Audio: AI narration via kokoro-tts, confident pace
• Production tool: Remotion (spring animations for layer reveals) + screen recordings
• Transitions: Fast cuts (0.3s) between scenes, spring scale for architecture reveal

LinkedIn Post

Post

We built an operating system for AI agents. Not a framework — an OS. In Rust.

Most agent "frameworks" are Python scripts calling an LLM in a loop. They crash, forget context between sessions, and have zero concept of budget or self-preservation. We asked: what if agents had real infrastructure?

The Life Agent OS has 7 subsystems covering everything an autonomous agent needs — from event-sourced memory that can replay any decision, to a homeostasis controller that automatically throttles agents burning too much budget.

Why it matters:

• Event-sourced persistence means every agent action is an immutable journal entry — fully debuggable, replayable, branchable • Homeostatic regulation gives agents operational, cognitive, and economic stability controls • Real financial agency via x402 protocol — agents can earn, spend, and manage budgets • Rust gives us memory safety, zero-cost abstractions, and WASM portability — no GC pauses in hot agent loops

The entire codebase is open source: 7 Rust crates, ~15K lines, production-ready.

If you're building AI systems that need to be reliable, not just clever — this is the infrastructure layer.

Full deep dive on the architecture: broomva.tech/writing/agent-os-launch

#AgentOS #Rust #AIInfrastructure #OpenSource #AutonomousAgents

Post Metadata

• Hook length: 82/210 characters
• Total length: 1,147/1,300 characters
• Hashtags: 5
• Image: media/thumbnails/linkedin-card.png
• Posting time: Day 1, 12 PM ET
• Document carousel: no

Media Generation Prompts — Agent OS Launch

Hero Image

Concept: A layered operating system architecture rendered as a sleek dark technical diagram — 7 glowing layers stacked vertically, each representing a subsystem, with data flowing between them. Prompt: A sleek dark-themed technical illustration for a blog post about building an Agent Operating System in Rust. Seven horizontal layers stacked vertically like geological strata, each glowing with a different accent color (blues, purples, cyans). Data streams flow between layers as luminous particles. Dark background (#0A0A0A), clean composition, no text. Professional, futuristic, minimal. 1200×675 pixels. Dimensions: 1200×675 Model: gemini-3.1-flash-image Usage: Blog header, X thread image 1, LinkedIn post image, OG social card

Supporting Image 1 — Architecture Diagram

Concept: Clean technical diagram showing all 7 subsystems and their connections Prompt: A technical architecture diagram on dark background showing 7 interconnected modules labeled: Arcan (runtime), Lago (persistence), Autonomic (homeostasis), Haima (finance), Praxis (tools), Vigil (observability), Spaces (networking). Modules connected by thin glowing lines. Minimal, professional, engineering blueprint style. Blue accent (#3B82F6). 1200×800 pixels. Dimensions: 1200×auto Usage: Blog inline after architecture section, X thread tweet 3

Supporting Image 2 — Homeostasis Visualization

Concept: Three gauges representing operational, cognitive, and economic health — the autonomic regulation concept Prompt: Three circular gauge meters on dark background, labeled Operational, Cognitive, Economic. Each gauge shows a needle in the green zone with subtle glow. Below each: small icons (gear, brain, dollar). Clean data-dashboard aesthetic, blue (#3B82F6) and green (#22C55E) accents. 1200×675 pixels. Dimensions: 1200×auto Usage: Blog inline after homeostasis section, X thread tweet 5

Instagram Carousel

Overall concept: 9-slide educational carousel explaining the Agent OS architecture Tool: /pencil MCP with Arcan Glass design tokens Dimensions: 1080×1350 per slide Slide count: 9 Style: Dark background (#0A0A0A), AI Blue (#3B82F6) accents, bold sans-serif typography, consistent branding

Generation Commands

# Hero image
node -e "
const { GoogleGenAI } = require('@google/genai');
const fs = require('fs');
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
(async () => {
  const r = await ai.models.generateContent({
    model: 'gemini-3.1-flash-image',
    contents: 'A sleek dark-themed technical illustration for a blog post about building an Agent Operating System in Rust. Seven horizontal layers stacked vertically like geological strata, each glowing with a different accent color (blues, purples, cyans). Data streams flow between layers as luminous particles. Dark background, clean composition, no text. Professional, futuristic, minimal. 1200x675 pixels.',
    config: { responseModalities: ['TEXT', 'IMAGE'] },
  });
  for (const p of r.candidates[0].content.parts) {
    if (p.inlineData) {
      fs.writeFileSync('hero.png', Buffer.from(p.inlineData.data, 'base64'));
      console.log('Hero image saved');
    }
  }
})();
"

# Optimize and create platform variants
magick hero.png -resize 1200x675! media/png/hero-social-card-opt.png
magick hero.png -resize 1200x675! media/thumbnails/x-card.png
magick hero.png -resize 1200x628! media/thumbnails/linkedin-card.png

Building an Agent OS in Rust

Created: 2026-03-20 Slug: agent-os-launch Status: ready

Brief

An Agent Operating System built entirely in Rust — why we chose Rust for the agent runtime, how the architecture works, and what it means for autonomous AI agents.

Content Package

Media Assets

Deploy to broomva.tech

cp broomva-tech-post.mdx ~/broomva/broomva.tech/apps/chat/content/writing/agent-os-launch.mdx
mkdir -p ~/broomva/broomva.tech/apps/chat/public/images/writing/agent-os-launch/
cp media/png/* ~/broomva/broomva.tech/apps/chat/public/images/writing/agent-os-launch/
cp media/mp3/narration.mp3 ~/broomva/broomva.tech/apps/chat/public/audio/writing/agent-os-launch.mp3

X Post

Post (≤ 280 characters)

We built an operating system for AI agents. In Rust. 7 subsystems: runtime, memory, homeostasis, finance, tools, observability, networking. Open source.

github.com/broomva/life

Image

media/thumbnails/x-card.png

Notes

• Character count: 207/280
• Posting time: Day 4 after thread (standalone engagement trigger)
• Image attached: yes (hero architecture card)

X Thread

Thread (7 tweets)

1/7

We built an entire operating system for AI agents. In Rust.

Not a framework. Not a wrapper. An OS — with event-sourced memory, homeostatic self-regulation, and real financial agency.

Here's why:

2/7

Most "agent frameworks" are Python scripts that call an LLM in a loop.

They crash. They forget. They have no concept of budget, stability, or self-preservation.

We asked: what if agents had the same infrastructure rigor as the systems they control?

3/7

The Life Agent OS has 7 subsystems:

• Arcan — agent runtime (the kernel) • Lago — event-sourced persistence (memory) • Autonomic — homeostasis controller (stability) • Haima — agentic finance (payments) • Praxis — tool execution sandbox • Vigil — observability (OpenTelemetry) • Spaces — distributed networking

📸 Image: architecture diagram

4/7

Everything is event-sourced. Every action, every decision, every state change is an immutable journal entry in Lago.

You can replay an agent's entire history. Debug any decision. Branch timelines.

Memory isn't a vector DB lookup — it's a content-addressed, append-only truth.

5/7

The Autonomic controller runs 3-pillar regulation:

• Operational — task throughput, error rates • Cognitive — context usage, decision quality • Economic — budget tracking, spend gates

If an agent is burning cash or spiraling, Autonomic throttles it. Automatically.

📸 Image: homeostasis diagram

6/7

Why Rust?

• Zero-cost abstractions for hot agent loops • Memory safety without GC pauses • WASM compilation for edge deployment • Type system catches protocol violations at compile time

Python agents crash at runtime. Rust agents don't compile if the protocol is wrong.

7/7

The full codebase is open source.

7 crates. ~15K lines of Rust. Production-ready event journal, SSE streaming, JWT auth, RBAC, and a knowledge graph with scored search.

Star, explore, contribute: github.com/broomva/life

Thread Strategy

• Hook formula: Transformation (built X instead of Y)
• Image placement: Tweets 3, 5
• Posting time: 9 AM ET (Tuesday or Wednesday)
• Reply engagement: Reply to own thread with "AMA about the architecture — happy to go deep on any subsystem"

/blog-post — Full-Stack Content Production Skill

Turn a topic into a complete publishing package: long-form post + platform-native social adaptations + multimedia assets.

What It Does

Given a topic, idea, or content brief, this skill produces a structured content package under /broomva/posts/ containing:

Quick Start

/blog-post "Building an Agent OS in Rust" — developers, educate, provocative tone

Compounding Skills

This skill orchestrates — it delegates to:

• /content-creation — storytelling, visual strategy, social patterns, AI generation
• /deep-research — multi-source research when needed
• /agent-browser — screenshots and reference extraction
• /pencil — carousel design, social cards
• /remotion-best-practices — video composition
• /arcan-glass — BroomVA brand styling

Output Structure

/broomva/posts/{YYYY-MM-DD}-{slug}/
├── README.md, brief.md, research.md, outline.md
├── broomva-tech-post.mdx (or substack-post.md)
├── x-post.md, x-thread.md, linkedin-post.md
├── instagram-post.md, instagram-reel.md
├── media/ (prompts + generated assets)
└── strategy/ (audience, platform, distribution, CTA)

Installation

npx skills add broomva/blog-post

Skill Structure

blog-post/
├── SKILL.md              — Skill definition (pipeline, phases, agent behavior)
├── README.md              — This file
├── references/            — Deep-dive guides loaded on demand
│   ├── content-brief-intake.md
│   ├── angle-selection.md
│   ├── platform-adaptation.md
│   ├── multimedia-production.md
│   ├── quality-checklist.md
│   └── output-structure.md
├── templates/             — Reusable templates for each output file
│   ├── brief.md, broomva-tech-post.mdx, substack-post.md
│   ├── x-post.md, x-thread.md, linkedin-post.md
│   ├── instagram-post.md, instagram-reel.md
│   ├── distribution-plan.md, media-prompts.md
└── examples/              — Complete example output package
    └── 2026-03-20-agent-os-launch/

Angle Selection

Why Angle Matters

The angle is the difference between "another post about X" and "the definitive post about X from this perspective." Without a clear angle, content becomes generic — a summary of widely available information that adds nothing to the conversation.

The Angle Test

A good angle passes all three: 1. Specificity — Could someone else write this exact post? If yes, the angle is too broad. 2. Tension — Does this challenge, reveal, or reframe something? If it only confirms, it's a summary. 3. Evidence — Can you back it with data, experience, or concrete examples? If not, it's opinion without weight.

Angle Discovery Process

Step 1: Map the landscape

What has already been said about this topic? Identify 3-5 existing takes. Your angle should be adjacent to but distinct from these.

Step 2: Find the gap

Look for:

• Unexplored combinations — "X through the lens of Y" (e.g., control theory applied to AI agents)
• Counter-narratives — "Everyone says X, but our data shows Y"
• Scale shifts — "What changes when you go from 1 to 1000?"
• Time shifts — "What we knew then vs. what we know now"
• Practitioner perspective — "What the tutorials don't tell you"

Step 3: Stress-test the angle

Ask: "If I wrote the headline, would someone click it over the other 5 posts on this topic?" If not, sharpen.

Angle × Framework Pairing

Common Angle Mistakes

• The roundup — "10 things about X" with no through-line. Fix: pick the 1 that matters most and go deep.
• The tutorial — Step-by-step without the "why." Fix: lead with the insight, then show how.
• The announcement — Feature list without impact. Fix: lead with the problem it solves for the reader.
• The echo — Restating what others said. Fix: add your own data, experience, or counter-evidence.
• The hedge — "X might be interesting." Fix: take a position. The reader can disagree.

Angle Statement Format

Write the angle as a single sentence that captures the tension:

"While most teams [common approach], we discovered that [contrarian finding] by [unique method], resulting in [specific outcome]."

This sentence becomes the backbone of every adaptation — the long-form post develops it fully, the X thread distills it, the LinkedIn post professionalizes it, and the Instagram carousel visualizes it.

Content Brief Intake

Purpose

The content brief is the single source of truth for the entire publishing package. A well-structured brief eliminates ambiguity downstream — every adaptation, media asset, and CTA traces back to decisions made here.

Gathering the Brief

When the user provides a full brief

Accept it as-is. Validate completeness against required fields. Fill obvious gaps with sensible defaults and confirm.

When the user provides only a topic

Use this questioning sequence (ask all at once, not one-by-one):

1. Who is this for? (developers, founders, general audience, specific community) 2. What should they do after reading? (try something, follow, subscribe, share, change their thinking) 3. What's the core insight? (the one thing that makes this worth reading) 4. Any references or prior work to build on? (URLs, posts, papers, experiences) 5. Which platforms matter most? (all, or prioritize specific ones)

If the user says "just write it," infer from context:

• Topic complexity → audience level
• User's own expertise → tone
• Topic novelty → intent (educate if new, persuade if contrarian, announce if launch)

When the user provides a reference URL

Extract the reference content first (using /agent-browser or FxTwitter API for X posts), then ask: "Do you want to respond to this, build on it, or create something inspired by it?"

Brief Validation

A brief is complete when you can answer:

• What is the one sentence this post exists to communicate?
• Who specifically will find this valuable?
• What action should they take?
• What evidence supports the core claim?

A brief is too vague when:

• The topic is a single word without context ("AI", "Rust", "design")
• No clear audience or intent
• No unique angle distinguishing it from every other post on the topic

Inferring Defaults

Multimedia Production

Philosophy

Media is not decoration — it is content. Each asset must advance the narrative, not just break up text. If an image doesn't make the post better without its caption, it's the wrong image.

Asset Production Matrix

Hero Image Generation

Every post needs a hero image. It becomes the social card thumbnail, blog header, and visual anchor.

Nano Banana (Gemini Images) prompt pattern:

A [style] technical illustration for a blog post about [topic].
[Visual concept tied to the post's core metaphor].
Dark background, [accent color] highlights, clean composition.
Professional, modern, minimal text. 1200x675 pixels.

Style directions by post type:

• Technical deep dive → architectural diagram aesthetic, circuit-board patterns
• Personal reflection → abstract, organic, soft gradients
• Case study → data visualization aesthetic, charts, metrics
• Launch/announcement → product showcase, hero shot, bold typography
• Opinion/contrarian → visual tension, contrast, unexpected juxtaposition

API call (using @google/genai):

import { GoogleGenAI } from "@google/genai";
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const response = await ai.models.generateContent({
  model: "gemini-3.1-flash-image",
  contents: "[prompt]",
  config: { responseModalities: ["TEXT", "IMAGE"] },
});
// Save inline data as PNG

Supporting Images

Placement rule: One image per ~300 words. Articles with images every 75-100 words get 2× more social shares.

Types and when to use:

• Screenshots — Process walkthroughs, UI evidence. Crop to relevant area.
• Diagrams — Architecture, workflows, system design. Strongest brand differentiation.
• Data viz — Metrics, comparisons, trends. Bar for categories, line for time series.
• AI-generated — Conceptual illustrations, mood images. Never for evidence.

Optimization:

# Resize and optimize
magick input.png -resize 1200x -quality 85 output-opt.png

# Naming convention
{subject}-{descriptor}-opt.png

Video Production

Remotion Composition (15-30s blog video)

Scene structure:

Title (3-4s) → Key Stat (3s) → Screenshots/Evidence (2-3s each) → Workflow (3-4s) → Closing CTA (3-4s)

Key rules:

• Use Img + staticFile() (never <img> tag)
• Use spring() for organic motion (never CSS transitions)
• Use <Sequence> with premountFor for preloading
• Include -movflags +faststart in any ffmpeg preprocessing for AI clips

Veo 3.1 AI Video Clips

For cinematic B-roll, product demos, abstract visuals:

• 720p/1080p/4K, 4/6/8 seconds per clip
• Native audio at 48kHz
• Chain up to 20 clips (~148s total)
• Aspect ratios: 16:9 (blog) or 9:16 (reels)

GIF Creation

# From video
ffmpeg -y -i video.mp4 -vf "fps=12,scale=960:-1:flags=lanczos" -c:v gif output.gif

# From image sequence (2s per frame)
magick f1.png f2.png f3.png -resize 1200x675! -set delay 200 -loop 0 flow.gif

When to use GIF: Micro-interactions, quick UI flows, loop-worthy moments. Max one per post.

Audio Narration

Script Preparation

1. Extract post body text (strip frontmatter and markdown formatting) 2. Add natural pause markers: [pause] between sections, [beat] for emphasis 3. Spell out abbreviations on first use: "AI (artificial intelligence)" 4. Note pronunciation: "Lago (LAH-go)", "Arcan (AR-kan)"

Generation

# kokoro-tts (fast, good quality, local)
kokoro-tts post-body.txt /tmp/narration.wav --voice af_sarah

# Convert to MP3
ffmpeg -i /tmp/narration.wav -codec:a libmp3lame -b:a 128k narration.mp3

# Edge TTS (free, Microsoft Neural voices)
edge-tts --text "$(cat post-body.txt)" --write-media narration.mp3 --voice en-US-AriaNeural

Integration with broomva.tech

1. Place MP3 at public/audio/writing/{slug}.mp3 2. Add audio: /audio/writing/{slug}.mp3 to post frontmatter 3. The ContentArticle component renders a native <audio> player automatically

Media Prompt File Format

In media/image-prompts.md, structure prompts as:

## Hero Image
**Concept**: [What the image represents conceptually]
**Prompt**: [Full AI generation prompt]
**Dimensions**: 1200×675
**Style**: [dark-technical / organic-soft / data-viz / product-hero]
**Usage**: Blog header, X thread image 1, LinkedIn post image, OG card

## Supporting Image 1 — [Section Name]
**Concept**: [Tied to specific content in that section]
**Prompt**: [Full prompt]
**Dimensions**: 1200×auto
**Usage**: Blog inline after paragraph X

## Instagram Carousel Slides
**Concept**: [Overall carousel narrative]
**Slides**: [Number of slides, what each contains]
**Dimensions**: 1080×1350
**Tool**: /pencil MCP or manual design

Asset Naming Convention

{slug}/media/png/hero-social-card-opt.png
{slug}/media/png/section-1-architecture-opt.png
{slug}/media/png/section-3-metrics-opt.png
{slug}/media/gif/ui-flow-demo.gif
{slug}/media/mp4/blog-video-30s.mp4
{slug}/media/mp4/reel-vertical.mp4
{slug}/media/mp3/narration.mp3
{slug}/media/thumbnails/x-card.png
{slug}/media/thumbnails/linkedin-card.png
{slug}/media/thumbnails/ig-cover.png

Output Structure

Directory Convention

Each invocation produces a self-contained package at:

/broomva/posts/{YYYY-MM-DD}-{slug}/

Slug rules:

• Kebab-case, lowercase
• 3-6 words maximum
• No dates in slug (date is the prefix)
• Descriptive but concise: agent-os-rust, haima-payments-launch, control-theory-applied

Full Directory Tree

{YYYY-MM-DD}-{slug}/
│
├── README.md                    # Package manifest
├── brief.md                     # Content brief (input)
├── research.md                  # Research notes (may be empty for opinion pieces)
├── outline.md                   # Structural blueprint with angle + framework
│
├── broomva-tech-post.mdx        # Primary long-form (broomva.tech)
├── substack-post.md             # Alternative long-form (if requested)
│
├── x-blog-post.md               # X long-form article (multimedia-rich, freeform length)
├── x-post.md                    # X single post (280 chars)
├── x-thread.md                  # X thread (5-8 tweets)
├── linkedin-post.md             # LinkedIn post
├── instagram-post.md            # Instagram caption + carousel slide spec
├── instagram-reel.md            # Reel script with timing
│
├── media/
│   ├── image-prompts.md         # AI generation prompts for all images
│   ├── audio-script.md          # TTS-ready narration text
│   ├── video-script.md          # Remotion/video composition outline
│   ├── gif-concept.md           # GIF animation concept + creation command
│   │
│   ├── hero.png                 # Generated hero/social card
│   ├── thumbnails/
│   │   ├── x-card.png           # 1200×675
│   │   ├── linkedin-card.png    # 1200×628
│   │   └── ig-cover.png         # 1080×1350
│   ├── png/                     # Supporting static images
│   ├── gif/                     # Animated GIFs
│   ├── mp3/                     # Audio files
│   │   └── narration.mp3        # Blog narration
│   └── mp4/                     # Video files
│       ├── blog-video.mp4       # 16:9 blog/social video
│       └── reel-vertical.mp4    # 9:16 Instagram reel
│
└── strategy/
    ├── audience.md              # Who, where, what they care about
    ├── platform-strategy.md     # Per-platform approach + rationale
    ├── distribution-plan.md     # Publishing sequence + timing
    └── cta.md                   # Call-to-action strategy per channel

README.md Format

# {Post Title}

**Created**: {YYYY-MM-DD}
**Slug**: {slug}
**Status**: draft | ready | published

## Brief
{One-sentence summary from brief.md}

## Content Package

| File | Status | Platform |
|------|--------|----------|
| broomva-tech-post.mdx | ✅ ready | broomva.tech |
| x-post.md | ✅ ready | X |
| x-thread.md | ✅ ready | X |
| linkedin-post.md | ✅ ready | LinkedIn |
| instagram-post.md | ✅ ready | Instagram |
| instagram-reel.md | ✅ ready | Instagram |

## Media Assets

| Asset | Status | Notes |
|-------|--------|-------|
| hero.png | ⏳ prompt ready | Run Nano Banana with prompt from image-prompts.md |
| narration.mp3 | ⏳ script ready | Run kokoro-tts with audio-script.md |
| blog-video.mp4 | ⏳ script ready | Render Remotion composition |

## Publishing

See `strategy/distribution-plan.md` for recommended sequence.

## Deploy to broomva.tech

\```bash
cp broomva-tech-post.mdx ~/broomva/broomva.tech/apps/chat/content/writing/{slug}.mdx
cp -r media/png/ ~/broomva/broomva.tech/apps/chat/public/images/writing/{slug}/
cp media/mp3/narration.mp3 ~/broomva/broomva.tech/apps/chat/public/audio/writing/{slug}.mp3
\```

File Status Indicators

Conditional Files

Not all files are always generated:

• substack-post.md — Only if destination: substack in brief
• research.md — May be minimal for personal/opinion posts
• media/mp4/ — Only if mp4 in media targets
• media/mp3/ — Only if mp3 in media targets
• media/gif/ — Only if gif in media targets or a demo-oriented post

Always create the file but mark as "❌ Not targeted" if skipped, so the package structure remains predictable.

Platform Adaptation

Core Principle

The same message expressed in platform-native language. Never copy-paste and truncate. Each platform has its own attention economy, consumption pattern, and audience expectation.

X Blog Post (Long-Form Article)

Purpose: Full long-form article published natively on X. Keeps users on-platform (algorithm rewards this). Rich inline media — images, GIFs, video clips play natively.

How it differs from broomva.tech post:

• More conversational and opinionated (less documentation-style)
• Higher media density — 1 visual per section (~150-200 words)
• Shorter paragraphs (2-3 sentences max)
• Personal voice ("I built this" not "one could build this")
• Provocative hook over informational hook

Media-first rule: Every section must have at least one visual asset:

• Hero image (Imagen 4.0 — striking, thumbnail-worthy)
• Architecture diagrams, flowcharts
• GIFs (terminal recordings, UI flows, demos)
• Short video clips (8-15s Veo 3.1)
• Code screenshots (syntax-highlighted, not raw text)
• Stat cards and data visualizations

Structure:

Hero image (full-width, stops scrolling)
Hook (1-2 sentences — provocative or meta)
---
Section 1: Setup (2-3 paragraphs + visual)
Section 2: Core insight (teaching + diagram/code + optional GIF)
Section 3: Evidence (data + stat card)
Section 4: How (walkthrough + video/GIF)
Closing (1 paragraph + natural CTA)

Hook formulas:

• "I [did something]. Here's everything I learned."
• "This [artifact] was built by the thing it describes."
• "[Surprising stat]. And I can prove it."
• "Everyone is doing [X]. We did [Y] instead."

What works: Strong opinions backed by evidence, multimedia-dense sections, personal narrative What fails: Documentation tone, walls of text without visuals, vague claims, generic AI art

See references/x-blog-post.md for the full guide.

X Single Post (280 chars)

Purpose: Standalone insight that earns engagement (likes, replies, reposts). Also the primary format for building-in-public updates, contrarian takes, and moment surfing.

Structure:

• One surprising claim, stat, or reframe
• ALWAYS attach an image (text-only posts get 60% less reach)
• No external links in post body (X suppresses them) — put links in self-reply
• Include an engagement hook: question, contrarian frame, or invitation to reply

What works:

• Specific numbers: "We reduced build times from 47 minutes to 3.2 seconds"
• Contrarian takes: "The biggest lie in AI: you need more data"
• Concise frameworks: "3 rules for X: [rule]. [rule]. [rule]."
• Questions that provoke: "Why does every AI startup look the same?"
• Terminal screenshots showing real work running
• Before/after comparisons with visuals
• Tagging 1-2 accounts whose work you build on (genuine credit, not attention-seeking)

What fails:

• Generic motivational content
• External links in the post body (kills reach — use self-reply)
• Text-only posts without images
• Passive observations ("Interesting that...")
• Thread teasers in a single post ("A thread on why X is important")
• Tagging for attention without substance

Growth patterns (see x-growth-strategy.md):

• Build in public: Terminal screenshot + 1-2 line insight (3-5x/week)
• Contrarian take: Strong opinion backed by your data/experience (1-2x/week)
• Moment surfing: React to breaking news with your running code (opportunistic)
• Strategic reply: Reply to big accounts with substance + your screenshot (3-5x/day)
• Day N update: "Day 47 of building X in Rust" + progress image (daily optional)

X Thread (5-8 tweets)

Purpose: Develop an argument in tweet-sized beats. Each tweet stands alone while building momentum. Best format for "How I built X" stories, technical deep dives, and comparison posts.

Structure (7-tweet sweet spot):

1/7 — HOOK: The single most compelling claim or stat
      This tweet determines everything. Spend 50% of effort here.
      ALWAYS attach hero image (terminal, result, diagram)
      Tag 1-2 accounts if crediting their work (their engagement amplifies reach)
      Formula options:
        "[Number] [things] in [timeframe]. Here's what happened:"
        "Most [role]s think [belief]. The data says otherwise:"
        "We replaced [old] with [new]. The results:"

2/7 — CONTEXT: Set the scene (1-2 sentences, establish what was normal)

3/7 — INSIGHT 1: First key finding or argument
      [attach image — increases completion by 45%]

4/7 — INSIGHT 2: Second key finding, builds on the first

5/7 — INSIGHT 3: Third finding or the "but" moment
      [attach image — data viz, screenshot, or diagram]

6/7 — EVIDENCE: Strongest proof point, most surprising result

7/7 — CTA: Drive engagement, not just clicks
      "What's your experience with X? Reply below."
      or "We're going deeper in Discord: [invite]"
      [Put external links in self-reply, not here]

Self-reply: Post immediately after thread with external link + Discord invite. This is where links go — X doesn't suppress links in replies as aggressively.

Rules:

• Number tweets explicitly (1/7, 2/7...)
• One idea per tweet — never wall of text
• Generous line breaks between ideas
• Image every 2-3 tweets (tweet 1 ALWAYS has an image)
• Post full chain immediately via self-reply (don't trickle)
• Native images/video only — never external media links

LinkedIn Post (1300 chars)

Purpose: Professional credibility, thought leadership, drive traffic to long-form.

Structure:

[HOOK — first 210 characters, before "See More" fold]
This is the most important part. It must create curiosity or state a bold claim.

[2-3 short paragraphs with key insights]
Use concrete numbers and specific examples.
Avoid corporate jargon — write like a smart person talking to peers.

Key takeaways:
• [Takeaway 1 — specific and actionable]
• [Takeaway 2]
• [Takeaway 3]
• [Takeaway 4 — optional]

[CTA — clear ask]
Link to the full post, ask a question, or invite discussion.

#tag1 #tag2 #tag3 (3-5 max, relevant, not trending-chasing)

What works:

• Opening with a personal experience or confession
• Specific metrics and outcomes
• "Here's what I learned" framing
• Bullet lists (LinkedIn's algorithm favors them)
• Asking a genuine question at the end

What fails:

• "I'm thrilled to announce..." (engagement killer)
• Long unbroken paragraphs
• More than 5 hashtags
• Tagging people who aren't genuinely relevant
• Humble-bragging without substance

Hook formulas:

• "I [did something unexpected]. Here's why:"
• "[Surprising stat]. Most people don't realize..."
• "The hardest lesson I learned about [topic]:"
• "Stop doing [common practice]. Do this instead:"
• "3 years ago, I [situation]. Today, [outcome]."

Instagram Post (Caption + Carousel)

Purpose: Visual-first education. The carousel teaches; the caption adds depth.

Carousel specs:

• Aspect ratio: 4:5 (1080×1350px) for maximum feed presence
• Slides: 8-12 for educational content
• Design tool: /pencil MCP for custom slides

Slide structure:

Slide 1  — COVER: "Is this for me?" + "What will I get?" in ≤10 words
           Bold title, clean design, branded colors
Slide 2  — PROBLEM: The pain point (bold key phrase, 1-2 sentences max)
Slide 3  — INSIGHT 1: One point per slide, flashcard style
Slide 4  — INSIGHT 2: Visual > text. Use icons, diagrams, code snippets
Slide 5  — INSIGHT 3
Slide 6  — INSIGHT 4
Slide 7  — STAT: Key metric in large typography
Slide 8  — SUMMARY: 3-4 bullet takeaways
Slide 9  — CTA: "Save this for later 🔖" / "Share with someone who needs this"

Caption structure (up to 2200 chars):

[Hook — first line visible in feed]

[Story or context that adds depth beyond the carousel]

[Key insight not in the carousel — reward for reading]

[CTA: Save, share, follow, or link in bio]

.
.
.
#hashtags (20-30, mix of broad and niche, hidden after dots)

What works:

• Swipeable education (Instagram users love learning in slide format)
• Clean, consistent design across slides
• One visual concept per slide (not cramming)
• Mixing text slides with image/screenshot slides

Instagram Reel (15-60s script)

Purpose: Discoverability. Reels reach non-followers more than any other format.

Script structure:

[0-3s]  HOOK: Visual or verbal pattern interrupt
        "Here's something nobody tells you about [topic]"
        or: Start with the result, then rewind

[3-8s]  PROBLEM: Quick setup of the tension
        "Every developer faces [problem]"

[8-25s] INSIGHT: Core value of the post
        Show, don't just tell. Screen recordings, diagrams, demos.
        If talking head: fast cuts, no filler words

[25-40s] EVIDENCE: Proof point (metric, demo, before/after)

[40-55s] TAKEAWAY: One clear lesson

[55-60s] CTA: "Follow for more" / "Link in bio" / "Save this"

Technical specs:

• Aspect ratio: 9:16 (1080×1920px)
• Duration: 15-60s (30s sweet spot for educational)
• Captions required (80% watch without sound)
• Trending audio optional (helps discovery but not required for educational)

Production options:

• Remotion — Programmatic composition with spring() animations, <Sequence> timing
• Veo 3.1 — AI-generated B-roll clips (9:16, up to 8s per clip, chain up to ~148s)
• Screen recording — Best for code demos and UI walkthroughs

Cross-Platform Consistency

While each adaptation is unique, maintain: 1. Same core message — The one-sentence angle statement appears in every piece (adapted per platform) 2. Visual identity — Same color palette, font style, hero image across platforms 3. CTA alignment — All roads lead to the same action (even if phrased differently) 4. Fact consistency — Same numbers, same claims, same evidence everywhere 5. Temporal coherence — Distribution timing creates a coordinated narrative, not random noise

Publishing Automation

Overview

Distribution uses native CLI tools and REST APIs — no third-party services. Each platform connector is independent; the skill gracefully degrades when a connector is unavailable.

X/Twitter via xurl

Setup (one-time)

# 1. Register app (needs X Developer Portal credentials)
xurl auth apps add broomva --client-id YOUR_CLIENT_ID --client-secret YOUR_CLIENT_SECRET

# 2. Set as default
xurl auth default broomva

# 3. OAuth2 flow (opens browser)
xurl auth oauth2

# 4. Verify
xurl whoami

Posting a Single Tweet

# Read the post content (first non-header, non-metadata line)
POST_TEXT=$(sed -n '/^## Post/,/^## /{ /^## /d; /^$/d; p; }' x-post.md | head -1)

# Post with optional image
if [ -f media/thumbnails/x-card.png ]; then
    xurl post "$POST_TEXT" --media media/thumbnails/x-card.png
else
    xurl post "$POST_TEXT"
fi

Posting a Thread

Threads are reply chains. The first tweet is a standalone post; subsequent tweets reply to the previous one.

Parsing x-thread.md: The file uses ### N/N headers to delimit tweets. Lines starting with 📸 Image: indicate media attachments.

#!/bin/bash
# publish-thread.sh — Parse x-thread.md and post as thread
THREAD_FILE="$1"
MEDIA_DIR="$(dirname "$THREAD_FILE")/media"
PREV_ID=""

# Extract tweets between ### headers
awk '/^### [0-9]+\/[0-9]+/{if(tweet)print tweet; tweet=""; next} {tweet=tweet" "$0} END{if(tweet)print tweet}' "$THREAD_FILE" | while IFS= read -r tweet_text; do
    # Clean up whitespace
    tweet_text=$(echo "$tweet_text" | sed 's/^ *//;s/ *$//' | tr -s ' ')

    # Check for image reference
    IMAGE=""
    if echo "$tweet_text" | grep -q "📸 Image:"; then
        IMAGE_REF=$(echo "$tweet_text" | grep -o "📸 Image: .*" | sed 's/📸 Image: //')
        # Remove image line from tweet text
        tweet_text=$(echo "$tweet_text" | grep -v "📸 Image:")
        # Resolve image path
        if [ -f "$MEDIA_DIR/png/$IMAGE_REF" ]; then
            IMAGE="$MEDIA_DIR/png/$IMAGE_REF"
        elif [ -f "$IMAGE_REF" ]; then
            IMAGE="$IMAGE_REF"
        fi
    fi

    # Post or reply
    if [ -z "$PREV_ID" ]; then
        # First tweet
        if [ -n "$IMAGE" ]; then
            RESULT=$(xurl post "$tweet_text" --media "$IMAGE" 2>&1)
        else
            RESULT=$(xurl post "$tweet_text" 2>&1)
        fi
    else
        # Reply to previous
        if [ -n "$IMAGE" ]; then
            RESULT=$(xurl reply "$PREV_ID" "$tweet_text" --media "$IMAGE" 2>&1)
        else
            RESULT=$(xurl reply "$PREV_ID" "$tweet_text" 2>&1)
        fi
    fi

    # Extract tweet ID from response
    PREV_ID=$(echo "$RESULT" | jq -r '.data.id // empty' 2>/dev/null)
    if [ -z "$PREV_ID" ]; then
        echo "ERROR: Failed to post tweet. Response: $RESULT"
        exit 1
    fi
    echo "Posted tweet $PREV_ID"
done

xurl Command Reference

LinkedIn via REST API

Setup (one-time)

1. Create app at linkedin.com/developers 2. Add product: "Share on LinkedIn" → grants w_member_social scope 3. OAuth2 flow:

# 1. Get authorization code (open in browser)
CLIENT_ID="your_client_id"
REDIRECT_URI="http://localhost:8080/callback"
open "https://www.linkedin.com/oauth/v2/authorization?response_type=code&client_id=$CLIENT_ID&redirect_uri=$REDIRECT_URI&scope=openid%20profile%20w_member_social"

# 2. Exchange code for token (after browser redirect)
CODE="paste_code_from_redirect_url"
CLIENT_SECRET="your_client_secret"
curl -s -X POST "https://www.linkedin.com/oauth/v2/accessToken" \
  -d "grant_type=authorization_code&code=$CODE&redirect_uri=$REDIRECT_URI&client_id=$CLIENT_ID&client_secret=$CLIENT_SECRET" \
  | jq -r '.access_token' > ~/.config/blog-post/linkedin-token

# 3. Get your member URN
curl -s -H "Authorization: Bearer $(cat ~/.config/blog-post/linkedin-token)" \
  "https://api.linkedin.com/v2/userinfo" \
  | jq -r '.sub' > ~/.config/blog-post/linkedin-urn

Posting (Posts API v2 — current as of 2024+)

Note: The /v2/ugcPosts endpoint was deprecated in 2024. Use /v2/posts instead.

TOKEN=$(cat ~/.config/blog-post/linkedin-token)
URN=$(cat ~/.config/blog-post/linkedin-urn)

# Extract post body (skip markdown headers and metadata sections)
POST_BODY=$(sed -n '/^## Post$/,/^## Post Metadata$/{ /^## /d; p; }' linkedin-post.md | sed '/^$/d')

curl -s -X POST "https://api.linkedin.com/v2/posts" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -H "LinkedIn-Version: 202401" \
  -H "X-Restli-Protocol-Version: 2.0.0" \
  -d "{
    \"author\": \"urn:li:person:$URN\",
    \"commentary\": $(echo "$POST_BODY" | jq -Rs .),
    \"visibility\": \"PUBLIC\",
    \"distribution\": {
      \"feedDistribution\": \"MAIN_FEED\",
      \"targetEntities\": [],
      \"thirdPartyDistributionChannels\": []
    },
    \"lifecycleState\": \"PUBLISHED\",
    \"isReshareDisabledByAuthor\": false
  }"

Posting with Image

# 1. Initialize image upload
INIT_RESPONSE=$(curl -s -X POST "https://api.linkedin.com/v2/images?action=initializeUpload" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -H "LinkedIn-Version: 202401" \
  -d "{
    \"initializeUploadRequest\": {
      \"owner\": \"urn:li:person:$URN\"
    }
  }")

UPLOAD_URL=$(echo "$INIT_RESPONSE" | jq -r '.value.uploadUrl')
IMAGE_URN=$(echo "$INIT_RESPONSE" | jq -r '.value.image')

# 2. Upload image binary
curl -s -X PUT "$UPLOAD_URL" \
  -H "Authorization: Bearer $TOKEN" \
  --upload-file media/thumbnails/linkedin-card.png

# 3. Create post with image
curl -s -X POST "https://api.linkedin.com/v2/posts" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -H "LinkedIn-Version: 202401" \
  -H "X-Restli-Protocol-Version: 2.0.0" \
  -d "{
    \"author\": \"urn:li:person:$URN\",
    \"commentary\": $(echo "$POST_BODY" | jq -Rs .),
    \"visibility\": \"PUBLIC\",
    \"distribution\": {
      \"feedDistribution\": \"MAIN_FEED\",
      \"targetEntities\": [],
      \"thirdPartyDistributionChannels\": []
    },
    \"content\": {
      \"media\": {
        \"title\": \"Post image\",
        \"id\": \"$IMAGE_URN\"
      }
    },
    \"lifecycleState\": \"PUBLISHED\",
    \"isReshareDisabledByAuthor\": false
  }"

Instagram via Instagram Business Login API

Note: Uses the Instagram Graph API via graph.instagram.com (not the legacy Facebook Graph API approach).

Setup (one-time)

1. Convert Instagram to Business/Creator account 2. Create Meta app at developers.facebook.com → Business type 3. Add "Manage messaging & content on Instagram" use case 4. Add instagram_business_content_publish permission (Step 1 → Go to permissions and features) 5. Set up Instagram Business Login (Step 4) → add redirect URI: https://broomva.tech/api/auth/callback 6. Add Instagram accounts as Instagram Testers (App roles → Roles → Add People → Instagram Tester) 7. Accept tester invitations on Instagram (Settings → Apps and websites → Tester Invites) 8. Run OAuth flow:

# 1. Open authorization URL in browser
IG_APP_ID="your_instagram_app_id"
open "https://www.instagram.com/oauth/authorize?force_reauth=true&client_id=$IG_APP_ID&redirect_uri=https://broomva.tech/api/auth/callback&response_type=code&scope=instagram_business_basic%2Cinstagram_business_manage_messages%2Cinstagram_business_manage_comments%2Cinstagram_business_content_publish%2Cinstagram_business_manage_insights"

# 2. After authorization, extract code from redirect URL and exchange for short-lived token
CODE="paste_code_from_redirect_url"
IG_APP_SECRET="your_instagram_app_secret"
curl -s -X POST "https://api.instagram.com/oauth/access_token" \
  --data-urlencode "client_id=$IG_APP_ID" \
  --data-urlencode "client_secret=$IG_APP_SECRET" \
  --data-urlencode "grant_type=authorization_code" \
  --data-urlencode "redirect_uri=https://broomva.tech/api/auth/callback" \
  --data-urlencode "code=$CODE" | jq .
# Response includes: access_token, user_id, permissions

# 3. Exchange short-lived token for long-lived token (60 days)
SHORT_TOKEN="short_lived_token_from_step_2"
curl -s "https://graph.instagram.com/access_token?grant_type=ig_exchange_token&client_secret=$IG_APP_SECRET&access_token=$SHORT_TOKEN" \
  | jq -r '.access_token' > ~/.config/blog-post/instagram-token

# 4. Save user ID (from step 2 response)
echo -n "user_id_from_step_2" > ~/.config/blog-post/instagram-user-id

# 5. Verify
curl -s "https://graph.instagram.com/v19.0/me?fields=id,username,name,account_type&access_token=$(cat ~/.config/blog-post/instagram-token)" | jq .

Posting (image must be publicly accessible URL)

IG_TOKEN=$(cat ~/.config/blog-post/instagram-token)
IG_USER=$(cat ~/.config/blog-post/instagram-user-id)
IMAGE_URL="https://broomva.tech/images/writing/{slug}/hero.png"
CAPTION=$(sed -n '/^## Caption$/,/^## /{ /^## /d; p; }' instagram-post.md)

# Create media container → publish (two-step process)
CONTAINER=$(curl -s -X POST "https://graph.instagram.com/v19.0/$IG_USER/media" \
  --data-urlencode "image_url=$IMAGE_URL" \
  --data-urlencode "caption=$CAPTION" \
  --data-urlencode "access_token=$IG_TOKEN" | jq -r '.id')

curl -s -X POST "https://graph.instagram.com/v19.0/$IG_USER/media_publish" \
  -d "creation_id=$CONTAINER" \
  -d "access_token=$IG_TOKEN"

Token Refresh (before 60-day expiry)

# Refresh long-lived token (must be done before expiry, extends another 60 days)
curl -s "https://graph.instagram.com/refresh_access_token?grant_type=ig_refresh_token&access_token=$(cat ~/.config/blog-post/instagram-token)" \
  | jq -r '.access_token' > ~/.config/blog-post/instagram-token

Connector Status Check

Before publishing, verify which platforms are available:

# X — check xurl auth
xurl whoami >/dev/null 2>&1 && echo "✅ X: ready" || echo "❌ X: run 'xurl auth oauth2'"

# LinkedIn — check token file
[ -f ~/.config/blog-post/linkedin-token ] && echo "✅ LinkedIn: ready" || echo "❌ LinkedIn: setup needed"

# Instagram — check token file
[ -f ~/.config/blog-post/instagram-token ] && echo "✅ Instagram: ready" || echo "❌ Instagram: setup needed"

# broomva.tech — always available
echo "✅ broomva.tech: ready (git)"

Credential Security

• All tokens stored in ~/.config/blog-post/ — never in the repo
• Conversation bridge redacts --client-secret, --client-id, bearer tokens, and high-entropy strings
• Never log full API responses containing tokens
• LinkedIn tokens expire after 60 days — refresh via curl with refresh_token
• Instagram long-lived tokens last 60 days — renew before expiry

Quality Checklist

Run this checklist before marking a content package as complete. Each gate must pass or be explicitly waived with rationale.

Content Quality

Long-Form Post

• [ ] Title is specific and compelling (not generic "Thoughts on X")
• [ ] Opening hook creates curiosity or states a bold claim within 2 sentences
• [ ] Clear angle statement identifiable within first 3 paragraphs
• [ ] At least 3 evidence points (data, examples, screenshots, quotes)
• [ ] Closing has a memorable one-liner, not a summary rehash
• [ ] Reading time is appropriate (800-2500 words for most posts)
• [ ] No placeholder text or TODO markers remain

Factual Accuracy

• [ ] All statistics are sourced or from first-hand experience
• [ ] Technical claims are verifiable
• [ ] Dates and version numbers are current
• [ ] No speculative claims presented as facts

Platform Adaptation Quality

Unique Hooks (Critical)

• [ ] X post hook ≠ X thread hook ≠ LinkedIn hook ≠ Instagram caption opener
• [ ] Each hook is optimized for its platform's attention pattern
• [ ] No hook is a truncated version of another

X Post

• [ ] ≤ 280 characters
• [ ] Self-contained (understandable without clicking anything)
• [ ] Contains the single most surprising insight
• [ ] Image attached (REQUIRED — text-only gets 60% less reach)
• [ ] Image shows something real (terminal, diagram, data) — not generic AI art
• [ ] No external links in post body (links go in self-reply)
• [ ] Engagement hook present (question, contrarian frame, or reply invitation)
• [ ] Tags are genuine (1-2 max, only accounts whose work is referenced)

X Thread

• [ ] 5-8 tweets (not 3, not 15)
• [ ] Tweet 1 is the strongest hook (50% of effort spent here)
• [ ] Tweet 1 has an image attached (REQUIRED)
• [ ] Each tweet stands alone while building momentum
• [ ] Image attached every 2-3 tweets
• [ ] Tweets numbered (1/N format)
• [ ] No external links in thread body (links in self-reply)
• [ ] Final tweet drives replies or conversation (not just "read more")
• [ ] Self-reply with link/Discord invite planned
• [ ] Thread adds value a single post couldn't — if not, use X post instead

LinkedIn

• [ ] Hook ≤ 210 characters (before "See More" fold)
• [ ] Includes bullet list of 3-5 takeaways
• [ ] 3-5 relevant hashtags (not trending-chasing)
• [ ] Professional tone without corporate jargon
• [ ] Ends with a question or clear CTA

Instagram Post

• [ ] Carousel cover has ≤ 10 words
• [ ] 8-12 slides specified
• [ ] One concept per slide (flashcard, not paragraph)
• [ ] Caption adds depth beyond carousel content
• [ ] CTA includes "save" or "share" (highest-value IG actions)

Instagram Reel

• [ ] 3-second hook specified
• [ ] Script is 15-60 seconds
• [ ] Captions included (80% watch muted)
• [ ] 9:16 vertical format specified
• [ ] CTA at end

Media Quality

Images

• [ ] Hero image prompt is specific and tied to post concept
• [ ] Supporting image prompts are tied to specific content sections
• [ ] All dimensions specified correctly per platform
• [ ] Naming convention followed: {subject}-{descriptor}-opt.{ext}

Video (if targeted)

• [ ] Scene breakdown with duration per scene
• [ ] Total duration 15-30 seconds (or justified if longer)
• [ ] ffmpeg preprocessing includes -movflags +faststart
• [ ] Both 16:9 and 9:16 versions planned (if IG reel targeted)

Audio (if targeted)

• [ ] Script is narration-ready (no markdown, natural pauses)
• [ ] Pronunciation guides for technical terms included
• [ ] Target: MP3 128kbps

GIF (if targeted)

• [ ] Max one per post
• [ ] Shows a micro-interaction or flow preview (not a random animation)
• [ ] Width ≤ 960px, fps ≤ 12

Strategy Quality

Audience

• [ ] Target audience is specific (not "everyone")
• [ ] Audience's existing knowledge level is noted
• [ ] Audience's primary platform is identified

Distribution

• [ ] Publishing sequence specified (which platform first)
• [ ] Cross-linking strategy defined (blog ← social, social → blog)
• [ ] Timing gaps between platform posts noted

CTA

• [ ] Primary action is clear and specific
• [ ] CTA adapted per platform (not identical copy)
• [ ] CTA aligns with stated intent in brief

Package Completeness

• [ ] README.md lists all files and their status
• [ ] brief.md captures the input
• [ ] outline.md shows the structural decisions
• [ ] All targeted platform files exist
• [ ] media/ directory has prompt files for all planned assets
• [ ] strategy/ directory has all four files
• [ ] Any skipped items are explained (tool unavailable, not applicable, etc.)

Reel Production — From Script to Published Reel

The 3-Second Rule

Up to 50% of viewers drop off in the first 3 seconds. The hook determines everything. DM sends are the strongest algorithm signal for reach. Saves > Shares > Comments > Likes.

Reel Structure (3-Act, 15-45s)

[0-3s]  HOOK — Pattern interrupt. Movement, bold text, surprising visual.
              Must answer: "Why should I stop scrolling?"
[3-Xs]  VALUE — Core content. One insight per beat. Fast pacing.
              B-roll every 5-12s. Text overlays reinforce audio.
[X-end] CTA — Clear action. "Follow", "Link in bio", "Save this".
              Keep under 3 seconds.

Optimal length: 15-45 seconds. A 15s reel with 80% retention beats a 60s reel with 30%.

Hook Formulas (Proven)

Rule: Write the hook BEFORE the rest of the script. Spend 50% of creative effort here.

Veo 3.1 Prompting (Cinematic Quality)

5-Part Prompt Formula

[Cinematography] + [Subject] + [Action] + [Context] + [Style & Ambiance]

Optimal length: 3-6 sentences, 100-150 words.

Camera Movement Vocabulary

Veo responds best to precise cinematographic terms:

Shot Type Vocabulary

Style Direction

Reference film genres, directors, or visual styles:

• "Film noir lighting, high contrast shadows"
• "Wes Anderson symmetrical framing, pastel palette"
• "Cyberpunk neon aesthetic, rain-slicked surfaces"
• "Clean minimal tech aesthetic, dark background, blue accent lighting"

Key Rules

1. One camera verb, one lighting motif, one action per clip — avoid stacking 2. Specify three motion layers: primary (subject), camera-subject relationship, secondary (environment) 3. Always specify aspect ratio: "Vertical 9:16" for reels 4. Don't over-prompt — 100-150 words is the sweet spot 5. Include audio direction — Veo 3.1 generates native audio: "Ambient electronic hum", "Soft keyboard clicks"

Example Prompts

Tech terminal scene:

Medium shot, slow dolly forward. A developer's hands typing on a mechanical keyboard, screen reflecting in their glasses. Dark room, single monitor glow casting blue light. Shallow depth of field, focus on the screen showing code. Ambient electronic hum, soft keyboard clicks. Cyberpunk minimal aesthetic. Vertical 9:16.

Data flow visualization:

Crane shot descending. Abstract luminous data streams flowing through a dark void, splitting into branching paths. Electric blue and cyan particle effects. Each branch terminates at a glowing node. No people. Futuristic, clean, technical. Subtle ambient synthesizer. Vertical 9:16.

Platform success:

Locked-off tripod shot. A minimal dark interface showing four card elements. One by one, each card receives a bright green checkmark with a satisfying spring animation. Clean design, electric blue accents turning green. Soft chime on each checkmark. Vertical 9:16.

Subtitle & Text Overlay Best Practices

Design Rules

• Font: Sans-serif, high contrast (white on dark semi-transparent bg)
• Placement: Lower third, within safe zones (5-10% inside frame edges)
• Duration: Each text element on screen 1-2 seconds
• Sync: Frame-level precision with audio — never early, never late
• Size: Large enough for mobile viewing (minimum 40px equivalent)

Subtitle Generation

# Generate SRT from audio using whisper
whisper media/mp3/narration.mp3 --output_format srt --output_dir media/

# Or use edge-tts subtitles
edge-tts --text "..." --write-subtitles media/subtitles.srt

# Burn subtitles into video with ffmpeg
ffmpeg -i input.mp4 -vf "subtitles=media/subtitles.srt:force_style='FontName=Arial,FontSize=24,PrimaryColour=&HFFFFFF,OutlineColour=&H000000,Outline=2,Alignment=2'" output.mp4

Text Overlay in Remotion

// Use <Sequence> for timed text overlays
<Sequence from={0} durationInFrames={72}>
  <AbsoluteFill style={{justifyContent: 'flex-end', padding: 40}}>
    <div style={{
      background: 'rgba(0,0,0,0.7)',
      padding: '12px 24px',
      borderRadius: 8,
      fontSize: 32,
      color: 'white',
      fontFamily: 'Inter, sans-serif',
    }}>
      One sentence. Nine phases. Seven platforms.
    </div>
  </AbsoluteFill>
</Sequence>

Production Pipeline

Option A: Pure Veo 3.1 (AI-native, fastest)

Script → Veo prompts (1 per scene) → Generate clips → ffmpeg concat → Burn subtitles → Host → Publish

1. Write scene prompts from reel script (use 5-part formula) 2. Generate clips sequentially (8s each, avoid rate limits) 3. Download with API key auth 4. Concatenate: ffmpeg -f concat -i list.txt -c:v libx264 -movflags +faststart output.mp4 5. Burn subtitles: ffmpeg -i output.mp4 -vf subtitles=subs.srt final.mp4 6. Push to broomva.tech for public hosting 7. Publish via Instagram API with media_type=REELS

Option B: Veo + Remotion (hybrid, most control)

Script → Veo clips (B-roll) → Remotion composition (text, transitions, pacing) → Render → Host → Publish

1. Generate B-roll clips via Veo 3.1 2. Preprocess: ffmpeg -i clip.mp4 -c:v libx264 -movflags +faststart -r 30 processed.mp4 3. Build Remotion composition with <OffthreadVideo> + <Sequence> + text overlays 4. Render: npx remotion render Reel --output reel.mp4 5. Push + publish

Option C: Screen Recording + Remotion (most authentic for dev content)

Screen recordings → Remotion composition → Text overlays + transitions → Render → Host → Publish

Best for: code demos, terminal walkthroughs, product showcases.

Instagram Reel Publishing

IG_TOKEN=$(cat ~/.config/blog-post/instagram-token)
IG_USER=$(cat ~/.config/blog-post/instagram-user-id)

# Step 1: Create REELS container
CONTAINER=$(curl -s -X POST "https://graph.instagram.com/v19.0/$IG_USER/media" \
  --data-urlencode "media_type=REELS" \
  --data-urlencode "video_url=https://broomva.tech/videos/reel.mp4" \
  --data-urlencode "caption=Your caption" \
  --data-urlencode "share_to_feed=true" \
  --data-urlencode "access_token=$IG_TOKEN" | jq -r '.id')

# Step 2: Poll for FINISHED status
while true; do
  STATUS=$(curl -s "https://graph.instagram.com/v19.0/$CONTAINER?fields=status_code&access_token=$IG_TOKEN" | jq -r '.status_code')
  [ "$STATUS" = "FINISHED" ] && break
  sleep 10
done

# Step 3: Publish
curl -s -X POST "https://graph.instagram.com/v19.0/$IG_USER/media_publish" \
  -d "creation_id=$CONTAINER" -d "access_token=$IG_TOKEN"

Video Requirements (Instagram Reels)

Quality Checklist (Reel-Specific)

• [ ] Hook grabs attention in first 3 seconds (visual OR text, not just narration)
• [ ] Subtitles burned in (80% watch on mute)
• [ ] Text overlays within safe zones
• [ ] Pacing: no static shot longer than 5 seconds
• [ ] Audio: voice narration OR trending music (never silence)
• [ ] CTA in final 3 seconds
• [ ] 9:16 vertical, minimum 720x1280
• [ ] Total duration 15-45 seconds
• [ ] File includes -movflags +faststart for streaming

Self-Evolution Protocol

The /blog-post skill is designed to improve with every use. Each content package produced feeds back into the skill's knowledge, templates, and strategies.

Evolution Substrate

What Gets Better Over Time

Feedback Loop Architecture

PUBLISH → MEASURE → EXTRACT PATTERNS → UPDATE SKILL → NEXT PUBLISH

1. Publish content package to platforms 2. Measure after 48 hours: DM sends, saves, watch completion, reach 3. Extract patterns: What worked? What failed? Why? 4. Update skill: Promote winning patterns to templates, demote losers 5. Next publish benefits from accumulated knowledge

What to Measure (Priority Order)

X Growth Targets

See x-growth-strategy.md for the full growth playbook.

A/B Testing Protocol

For each content package, vary ONE element across platforms:

• Same content, different hooks (test hook formulas)
• Same hook, different posting times (test timing)
• Same content, different media (image vs. carousel vs. reel)
• Same message, different tone (technical vs. conversational)

Track which variation wins. After 5+ data points per variable, promote the winner to default.

Self-Improvement Triggers

After Every Publish

The agent should ask: 1. "Which platform performed best? What was different about that adaptation?" 2. "Did any hook significantly outperform others? Save it to proven-hooks." 3. "Did any Veo prompt produce an unusable clip? Annotate why." 4. "Were there quality gate failures in production? Add preventive checks."

Monthly Review

1. Review all content packages from the past month 2. Rank by engagement per platform 3. Identify the top 3 patterns and bottom 3 patterns 4. Update skill references with findings 5. Prune strategies that consistently underperform 6. Add new strategies observed from competitors or trends

Quarterly Evolution

1. Research current algorithm changes (Instagram, X, LinkedIn) 2. Update platform-adaptation.md with new best practices 3. Audit compounding skills — are there new skills worth adding? 4. Review media tooling — new AI models, new capabilities? 5. Update reel-production.md with new techniques 6. Version bump the skill and push to GitHub

Content Pillars (Bootstrap)

Define 3-5 recurring themes. Each content package should fit a pillar:

Each pillar has its own optimal format:

• Build logs → X thread + terminal screenshot posts + blog post
• Agent architecture → blog post + LinkedIn + X thread with diagrams
• Meta-content → all platforms (universal appeal)
• Open source → X thread + demo video (native) + blog post
• Contrarian takes → X post + LinkedIn + strategic replies to big accounts

X-First Content (Standalone — Not Derived from Blog Posts)

These content types live only on X and feed directly into growth:

• Terminal screenshot + insight — 3-5x/week, lowest effort, highest consistency signal
• Demo video (60-90s native) — 1x/week, highest reach potential (5-10x vs link posts)
• Day N updates — "Day 47 of building an Agent OS in Rust" + image, daily optional
• Strategic replies — Reply to watchlist accounts with substance + your screenshot, 3-5x/day
• Moment responses — React to breaking news with running code within 30 minutes

Compounding Skills Ecosystem

The /blog-post skill compounds on a growing ecosystem. New skills should be evaluated and integrated when they provide capabilities the skill currently handles manually.

Currently Compounding

Candidates for Future Integration

Integration Criteria

Add a compounding skill when: 1. The skill handles a task the /blog-post skill currently does manually 2. The skill has > 100 installs (validated by community) 3. The skill's output can be consumed by the pipeline without manual intervention 4. Adding it doesn't increase SKILL.md beyond 600 lines (use references for depth)

X Blog Post — Long-Form Articles on X

What It Is

X supports full long-form articles (formerly "Twitter Articles") with rich formatting, inline images, videos, GIFs, and no character limit. This is the X equivalent of a blog post — not a thread, not a tweet, but a complete article published natively on the platform.

Why It Matters

• Algorithm boost: Long-form content keeps users on-platform, which X's algorithm rewards with distribution
• Multimedia-native: Inline images, GIFs, and video clips play natively — no external links needed
• Engagement surface: Users can reply, quote, repost, and bookmark — driving all engagement signals
• SEO: X articles are indexed by search engines
• Distribution: Appears in feeds, search results, and follower timelines

How It Differs from broomva.tech Post

Content Strategy

The Multimedia-First Rule

Every section of an X blog post should be accompanied by at least one visual asset:

Media Generation Checklist

For each X blog post, generate: 1. Hero image — The thumbnail. Must be striking enough to stop scrolling. Use Imagen 4.0. 2. 1 supporting image per major section — Diagrams, screenshots, or AI illustrations 3. At least 1 GIF — Animated demo, terminal recording, or visual flow 4. Optional video clip — 8-15s Veo 3.1 clip for the most impactful section 5. Code screenshots — If showing code, use syntax-highlighted images (not raw text)

Writing for X's Audience

• Lead with the most provocative claim — X rewards strong opinions
• Use short paragraphs — 2-3 sentences max per paragraph
• Include personal experience — "I built this" > "One could build this"
• Be specific — Numbers, timelines, concrete results > vague claims
• End sections with a visual — Breaks up text, increases scroll depth
• Conversational tone — Write like you're explaining to a smart friend, not writing docs

Hook Formula for X Blog Posts

The hero image + first sentence determine whether anyone reads past the fold.

Hero image: Dark, technical, visually striking. Must communicate the topic at a glance without text.

First sentence patterns:

• "I [did something concrete]. Here's everything I learned." (earned insight)
• "This [artifact/system] was built by the thing it describes." (meta-proof)
• "[Surprising stat or claim]. And I can prove it." (data hook + confidence)
• "Everyone is doing [X]. We did [Y] instead. The results:" (contrarian)
• "In [timeframe], [outcome]. No [expected tool]. Here's the stack:" (constraint-driven)

Structure Template

# Title (clear, benefit-driven or curiosity-driven)

[Hero image — full width]

[Hook paragraph — 1-2 sentences, provocative or surprising]

## Section 1: The Setup
[Context in 2-3 short paragraphs]
[Supporting image or diagram]

## Section 2: The Core Insight
[Main teaching or argument]
[Code screenshot or architecture diagram]
[GIF demo if applicable]

## Section 3: The Evidence
[Data, metrics, before/after]
[Stat card or data visualization]

## Section 4: The How
[Implementation details or walkthrough]
[Video clip or terminal GIF]
[Code examples as images]

## Section 5: The Takeaway
[One memorable conclusion — single paragraph]
[CTA woven naturally into the narrative]

Publishing

X blog posts can be published via xurl as a regular post with the article content, or composed directly in the X web interface. For long-form with rich media:

1. Compose in X's editor — Upload images and video natively for best display 2. Or use the API — Post with xurl post including media attachments

For multimedia-rich articles, composing in the X web editor is recommended since it handles inline media positioning better than the API.

Media Upload via xurl

# Upload image, get media ID
MEDIA_ID=$(xurl media upload hero.png 2>&1 | jq -r '.media_id_string')

# Post with media
xurl post "Article text..." --media hero.png

Growth Integration

X blog posts are the long-form anchor that threads and posts can reference. For maximum growth impact:

1. Publish the X thread FIRST — it drives initial engagement and visibility 2. The blog post lives in the self-reply of the thread's final tweet — not in the thread body 3. Share terminal screenshots and demos as standalone X posts in the days following — each references back to the article 4. Tag relevant accounts in the thread tweet 1, not in the blog post itself 5. Embed the article link in your X bio or pinned post during its promotion window

See x-growth-strategy.md for the full growth playbook.

Quality Gates (X Blog Post Specific)

• [ ] Hero image is striking enough to stop scrolling (not generic AI art)
• [ ] Hero image shows something REAL — running code, architecture, data — not stock/AI filler
• [ ] Every section has at least one visual (image, GIF, or video)
• [ ] Opening sentence is provocative or surprising (not descriptive)
• [ ] Paragraphs are 2-3 sentences max
• [ ] At least 1 GIF showing something in action
• [ ] Tone is conversational, not documentation-style
• [ ] Personal experience or first-hand evidence included ("I built" not "one could build")
• [ ] No section longer than 200 words without a visual break
• [ ] Companion X thread drafted (article is promoted via thread, not posted in isolation)

X Growth Strategy — From Zero to Influential

A systematic playbook for growing an X presence as a developer/founder building in public. Not hype-farming — earning attention through visible, substantive work.

Core Thesis

Visibility = f(substance, frequency, timing, network)

You can have incredible work (substance) but if nobody sees it (frequency=0, network=0), it doesn't matter. The claw-code repo got 115K stars not because it was better than alternatives — it had 3 contributors and no license — but because the creator was already visible (WSJ feature, 25B tokens), shipped at the moment of maximum attention (the leak), and had an activated community (instructkr Discord).

The formula: be known before the moment arrives.

The Five Growth Levers

1. Build in Public (Substance + Frequency)

Every commit, every deploy, every architectural decision is potential content. The key is making the process visible, not just the result.

What to post (ranked by engagement potential):

What NOT to post:

• Generic AI takes ("AI will change everything") — zero signal
• Links without context — X suppresses external URLs
• Thread teasers as standalone posts ("A thread on why X matters") — just post the thread
• Retweets without commentary — add your perspective
• Anything without an image — text-only posts get 60% less reach

2. Strategic Replies (Network)

The #1 growth hack on X for small accounts. Replying to large accounts with substance puts you in front of their audience.

How to do it right:

• Show running code — If someone posts about AI agents, reply with a screenshot of your agent running. "Built something similar — here's what 17 crates of Rust agent infra looks like in action:" + image
• Add data — If someone makes a claim, confirm or challenge with your own numbers. "Can confirm — we measured X at Y when switching to Z"
• Offer the non-obvious perspective — Not "great post!" but "One thing this misses: [insight from your experience]"
• Be early — Reply within 30 minutes of the original post. First substantive replies get 10-50x the visibility of late ones
• Quote tweet > reply when you have enough to say. Quote tweets show to YOUR followers; replies show to THEIR followers

Who to reply to (build a watchlist):

• Anthropic engineers (when posting about Claude Code, agent patterns)
• Vercel team (when posting about AI SDK, deployments, infra)
• Rust community leaders (when posting about systems, performance)
• AI agent builders (rllm-org, OpenClaw maintainers, etc.)
• Tech journalists covering AI (when breaking news hits)

Track the watchlist: Use X lists (private). Check 2-3x/day. Reply to 3-5 posts/day with substance.

3. Moment Surfing (Timing)

The claw-code creator succeeded because he was first to ship a response when the leak happened. Every tech news cycle has moments of maximum attention. You need to be ready.

Predictable moments:

• Major model releases (Claude 5, GPT-6, etc.) → "Tested it in Noesis. Here's what changed:"
• Framework releases (Next.js 17, AI SDK v7) → "Updated our stack. Here's the migration:"
• Conference talks (Anthropic, Vercel, RustConf) → Real-time commentary + your angle
• Security incidents (OpenClaw CVE, npm supply chain) → "Here's a safer alternative:"

Unpredictable moments (be prepared):

• Keep a "ready to ship" queue of 3-5 draft posts/threads about your key projects
• Have demo videos pre-recorded that can be posted with timely context
• Keep terminal screenshots fresh — update weekly so they show recent work

Speed matters more than polish. A rough terminal screenshot posted 30 minutes after news breaks beats a polished graphic posted 6 hours later. The first credible response sets the narrative.

4. Tagging & Credit (Network Amplification)

Tag people whose work you build on — genuinely. This is not spam. It's the X equivalent of citing sources.

When to tag:

• "Built with @veraborunda's AI SDK — here's what streaming tool calls look like in Rust:" (genuine)
• "Inspired by @anthropaboricua's approach to context compaction — our implementation:" (credit)
• "Using @whoever's library in production. One thing the docs don't cover:" (adds value)

When NOT to tag:

• Don't tag for attention without substance
• Don't tag more than 2-3 accounts per post
• Don't tag the same person repeatedly (once per week max for non-interactions)

The reply-back effect: When you tag someone with genuine substance, they often like or reply. Their engagement puts your post in front of their entire audience. One reply from a 100K account can 10x your reach for that post.

5. Community Seeding (Discord → X Flywheel)

Discord and X reinforce each other:

• X attracts people → Discord gives them a place to stay
• Discord creates relationships → Those people engage on X
• Discord members share your X posts → Organic reach amplification

Discord → X patterns:

• "Just shipped X. Discussion in our Discord:" (drives Discord signups)
• Post your best Discord conversations as X content (with permission)
• Ask Discord members to share their builds → you retweet with commentary
• Discord-exclusive previews → members share on X for clout

X → Discord patterns:

• Pin Discord invite in X bio (always visible)
• End every major thread with Discord link
• Reply to commenters with "great question — we're discussing this in Discord"

Content Calendar Framework

Don't wing it. Plan a week of content in advance, leaving room for moment surfing.

Weekly cadence (minimum viable):

Every day: 3-5 substantive replies to watchlist accounts.

Post Anatomy for Maximum Reach

Image Posts (highest reach-to-effort ratio)

[1-2 line caption — provocative claim or specific insight]

[Image: terminal screenshot, architecture diagram, or before/after]

Why this works: Images stop scrolling. The caption creates context. No link to suppress. Native to the platform.

Thread Architecture (for complex topics)

1/N — HOOK: The single most compelling stat or contrarian claim
      [Image: hero — the result, the diagram, the proof]

2/N — CONTEXT: Why this matters right now (1-2 sentences)

3/N — INSIGHT 1: First key point
      [Image: supporting evidence]

4/N — INSIGHT 2: Builds on first

5/N — INSIGHT 3: The "but" or complication
      [Image: data or screenshot]

6/N — EVIDENCE: Strongest proof point

7/N — CTA: Link, question, or Discord invite

Thread engagement formula:

• Spend 50% of effort on tweet 1 (it determines everything)
• Add image every 2-3 tweets (increases thread completion by 45%)
• Number tweets explicitly (1/7, 2/7...) — creates commitment
• Self-reply immediately with all tweets (don't trickle — post the whole chain fast)

Native Video (highest reach potential)

[0-3s] Visual hook — terminal running, something building, result appearing
[3-15s] What this is and why it matters (voice or text overlay)
[15-60s] The demo — show it working
[60-90s] The takeaway + what to do next

Caption: 1-2 line summary + relevant tags

Critical: Upload as native video, NOT a YouTube/Vimeo link. X gives native video 5-10x the distribution of external links.

Growth Metrics to Track

Leading indicators (track weekly):

• Reply engagement from watchlist accounts (are big accounts noticing you?)
• Thread completion rate (are people reading to the end?)
• Profile visits / follower conversion (are visitors converting?)
• Quote tweets of your content (are people using you as evidence?)

Lagging indicators (track monthly):

• Follower growth rate
• Average impressions per post
• Inbound DMs and collaboration requests
• Discord signups attributed to X

Anti-Patterns (What Kills Growth)

The Broomva Advantage

What you have that most developers don't:

1. Unique positioning — Colombian founder building Rust agent infrastructure. Not another SF voice. 2. Deep technical stack — 17-crate Agent OS, 24 skills, working Claude Code fork. This is real, not a weekend project. 3. Multiple content angles — Rust systems, AI agents, open source, finance, ocean genomics, control theory. Each is a content pillar. 4. Self-referential proof — The agent stack creates its own content. The system documents itself. This is inherently interesting. 5. Contrarian potential — "Why I'm building the agent runtime in Rust, not TypeScript" is a post people will fight over (in a good way).

Your moat is substance. Most X accounts in AI are commentary. You have running code, published crates, deployed infrastructure. Lead with proof.

Integration with /blog-post Skill

When the /blog-post skill generates X content, it should:

1. Apply growth patterns — Every X post/thread should follow the anatomy above 2. Include visual proof — Terminal screenshots, architecture diagrams, demo GIFs 3. Tag strategically — Credit dependencies and inspirations (2-3 max per post) 4. Optimize for native reach — Images > links, native video > YouTube links 5. Include engagement hooks — Questions, contrarian framing, "reply with your experience" 6. Generate standalone X content — Not just blog adaptations, but X-first posts 7. Track growth metrics — Log engagement data for self-evolution

Content Brief

Core

• Topic: {topic}
• Intent: {educate | persuade | announce | reflect | document}
• Audience: {who specifically}
• Angle: {one-sentence angle statement — filled in Phase 2}

Configuration

• Destination: {broomva-tech | substack | medium | dev-to | hashnode}
• Tone: {confident-technical | conversational | academic | provocative | reflective | storytelling}
• Slug: {auto-generated-from-topic}

Platforms

• [x] broomva-tech (or alternative long-form)
• [x] X post
• [x] X thread
• [x] LinkedIn
• [x] Instagram post (carousel)
• [x] Instagram reel

Media Targets

• [x] PNG (hero + supporting images)
• [x] MP3 (audio narration)
• [ ] MP4 (video composition)
• [ ] GIF (animated preview)

References

• {URL or resource 1}
• {URL or resource 2}

Call to Action

• Primary CTA: {what should the reader do?}
• CTA per platform: {filled in Phase 7}

Notes

{Any additional context, constraints, or preferences}

Distribution Plan

Publishing Sequence

Cross-Linking Strategy

• Blog post is the canonical URL — all social links point here
• X thread tweet 7 links to blog
• LinkedIn CTA links to blog
• Instagram bio link updated to blog (or linktree)
• Blog post embeds video/reel if available

Posting Times (General Guidance)

Engagement Plan

• Reply to comments within 2 hours of posting
• Quote-tweet own thread with a follow-up insight on Day 2
• Share in relevant communities/Slack channels on Day 1
• Cross-post acknowledgment (e.g., "Expanded thread → full post")

Metrics to Track

Instagram Post

Carousel Slides (1080×1350px, 4:5 ratio)

Slide 1 — Cover

Text: {≤10 words — "Is this for me?" + "What will I get?"} Design: Bold title, clean background, branded colors

Slide 2 — Problem

Text: {The pain point — bold key phrase, 1-2 sentences max} Visual: {Icon or illustration concept}

Slide 3 — Insight 1

Text: {One key point — flashcard style} Visual: {Diagram, code snippet, or icon}

Slide 4 — Insight 2

Text: {One key point} Visual: {Supporting graphic}

Slide 5 — Insight 3

Text: {One key point} Visual: {Supporting graphic}

Slide 6 — Insight 4

Text: {One key point} Visual: {Supporting graphic}

Slide 7 — Key Stat

Text: {Large number or metric in bold typography} Visual: {Minimal — let the number speak}

Slide 8 — Summary

Text: {3-4 bullet takeaways} Visual: {Clean list design}

Slide 9 — CTA

Text: "Save this for later 🔖" or "Share with someone who needs this" Visual: {Profile reference, follow button concept}

Caption

{Hook — first line visible in feed, creates curiosity}

{Story or context that adds depth beyond the carousel — reward for reading the caption}

{Key insight NOT in the carousel}

{CTA: Save, share, follow, or link in bio}

. . . {20-30 hashtags, mix of broad and niche}

Post Metadata

• Slide count: {N}
• Design tool: /pencil MCP
• Posting time: {recommended time}
• Alt text per slide: {yes — required for accessibility}

Instagram Reel

Script ({N} seconds, 9:16 vertical, 1080×1920px)

[0-3s] — HOOK

Visual: {Pattern interrupt — surprising visual, text overlay, or action} Audio/VO: "{Opening line — 'Here's something nobody tells you about...'}" Captions: {On-screen text for muted viewing}

[3-8s] — PROBLEM

Visual: {Quick setup of the tension — relatable scenario} Audio/VO: "{Problem statement}" Captions: {Key phrase on screen}

[8-25s] — INSIGHT

Visual: {Core value — screen recording, diagram, demo, talking head} Audio/VO: "{Main teaching content}" Captions: {Key points appear as text overlays} B-roll: {AI clip concept or screen recording plan}

[25-40s] — EVIDENCE

Visual: {Proof — metric, before/after, demo result} Audio/VO: "{Data or demonstration narrative}" Captions: {Stat or result on screen in large text}

[40-55s] — TAKEAWAY

Visual: {Summary frame or talking head} Audio/VO: "{One clear lesson}" Captions: {Takeaway text}

[55-60s] — CTA

Visual: {Profile card or subscribe prompt} Audio/VO: "Follow for more" / "Link in bio" Captions: {CTA text}

Production Notes

• Total duration: {N}s
• Aspect ratio: 9:16 (1080×1920)
• Captions: Required (80% watch muted)
• Audio: {Original VO / AI narration / trending audio}
• Production tool: {Remotion / Veo 3.1 / screen recording + ffmpeg}
• Transitions: {Cut / spring animation / zoom}

Vertical Crop Command (if converting from 16:9)

ffmpeg -i horizontal.mp4 -vf "crop=608:1080" -c:a copy vertical.mp4

LinkedIn Post

Post

{HOOK — first 210 characters, before "See More" fold. Bold claim or personal experience.}

{2-3 short paragraphs with key insights. Concrete numbers, specific examples. Write like a smart person talking to peers.}

Key takeaways: • {Takeaway 1 — specific and actionable} • {Takeaway 2} • {Takeaway 3} • {Takeaway 4 — optional}

{CTA — clear ask. Link to full post, question, or invitation to discuss.}

#tag1 #tag2 #tag3

Post Metadata

• Hook length: {N}/210 characters
• Total length: {N}/1300 characters
• Hashtags: {3-5, relevant}
• Image: {reference to media/thumbnails/linkedin-card.png}
• Posting time: {recommended time}
• Document carousel: {yes/no — attach PDF/PPTX if applicable}

{Post Title}

{Subtitle — one-sentence hook}

---

{Hook — 1-2 sentences that create curiosity or state a bold claim}

{Body content — standard Markdown, no frontmatter beyond what Substack expects}

{Use relative image paths or hosted URLs for images}

{Section 1}

{Content}

{Section 2}

{Content}

{Closing}

{Memorable takeaway}

---

{Brief author bio or context. CTA: Subscribe for more.}

X Post

Post (≤ 280 characters)

{Single most surprising or provocative insight. Self-contained. No external links — put links in self-reply.}

Image

{REQUIRED — always attach one. Options:} {- Terminal screenshot showing something real running} {- Architecture diagram or before/after comparison} {- media/thumbnails/x-card.png or media/png/hero-social-card-opt.png}

Engagement Hook

{One of:} {- Question: "What's your experience with X?"} {- Contrarian frame: "Everyone does X. We did Y instead."} {- Invitation: "Reply with your stack / approach / results"}

Tags

{1-2 relevant accounts — only when genuinely building on their work. Never tag for attention without substance.} {- @account1 — reason for tag} {- @account2 — reason for tag}

Self-Reply (posted immediately after)

{Link to full post, Discord invite, or additional context. External links go HERE, not in the main post — X suppresses external URLs in the main body.}

Notes

• Character count: {N}/280
• Posting time: {recommended time from distribution plan}
• Image attached: yes (required)
• Content type: {terminal-screenshot | architecture-diagram | before-after | contrarian-take | demo | day-n-update}
• Growth pattern: {build-in-public | moment-surfing | strategic-reply | standalone}