aigroup-workflow 1.0.0

package/skills/jarvis/engineering-team/marketing-skill/social-media-manager/scripts/social_calendar_generator.py

@@ -0,0 +1,399 @@
+#!/usr/bin/env python3
+"""
+social_calendar_generator.py — Social Media Content Calendar Generator
+100% stdlib, no pip installs required.
+
+Usage:
+    python3 social_calendar_generator.py                       # demo mode
+    python3 social_calendar_generator.py --config config.json
+    python3 social_calendar_generator.py --config config.json --json
+    python3 social_calendar_generator.py --config config.json --markdown > calendar.md
+    python3 social_calendar_generator.py --start 2026-04-01 --weeks 4
+
+config.json format:
+    {
+      "pillars": [
+        {"name": "Educational",    "description": "Tips, tutorials, how-tos", "emoji": "🎓", "weight": 3},
+        {"name": "Inspirational",  "description": "Success stories, quotes",  "emoji": "✨", "weight": 2},
+        {"name": "Product",        "description": "Features, demos",          "emoji": "🛠", "weight": 2},
+        {"name": "Community",      "description": "UGC, shoutouts, polls",    "emoji": "🤝", "weight": 1}
+      ],
+      "platforms": [
+        {"name": "LinkedIn",  "posts_per_week": 3, "best_days": ["Monday","Tuesday","Wednesday","Thursday"]},
+        {"name": "Twitter/X", "posts_per_week": 5, "best_days": ["Monday","Tuesday","Wednesday","Thursday","Friday"]}
+      ],
+      "start_date": "2026-04-07",
+      "weeks": 4
+    }
+"""
+
+import argparse
+import json
+import sys
+from datetime import date, timedelta
+from collections import defaultdict
+
+
+# ---------------------------------------------------------------------------
+# Defaults / sample data
+# ---------------------------------------------------------------------------
+
+DEMO_CONFIG = {
+    "pillars": [
+        {"name": "Educational",   "description": "Tips, tutorials, how-tos", "emoji": "🎓", "weight": 3},
+        {"name": "Inspirational", "description": "Success stories & quotes",  "emoji": "✨", "weight": 2},
+        {"name": "Product",       "description": "Feature demos & updates",   "emoji": "🛠 ", "weight": 2},
+        {"name": "Community",     "description": "UGC, polls & shoutouts",    "emoji": "🤝", "weight": 1},
+    ],
+    "platforms": [
+        {
+            "name": "LinkedIn",
+            "posts_per_week": 3,
+            "best_days": ["Monday", "Tuesday", "Wednesday", "Thursday"],
+            "content_type_hint": "Long-form insights, carousels, thought leadership",
+        },
+        {
+            "name": "Twitter/X",
+            "posts_per_week": 5,
+            "best_days": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
+            "content_type_hint": "Threads, quick tips, hot takes, polls",
+        },
+    ],
+    "start_date": None,   # defaults to next Monday
+    "weeks": 4,
+}
+
+CONTENT_TYPE_HINTS = {
+    "Educational":   ["How-to thread", "Quick tip", "Carousel: 5 steps", "Tutorial link"],
+    "Inspirational": ["Quote image", "Success story", "Before/after", "Motivational thread"],
+    "Product":       ["Feature demo GIF", "Changelog post", "Use-case spotlight", "Behind the scenes"],
+    "Community":     ["Poll", "User shoutout", "Question post", "Community highlight"],
+}
+
+WEEKDAY_NAMES = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
+
+
+# ---------------------------------------------------------------------------
+# Pillar scheduler — weighted round-robin
+# ---------------------------------------------------------------------------
+
+def build_pillar_sequence(pillars: list, length: int) -> list:
+    """
+    Build a balanced pillar rotation of `length` posts using weighted distribution.
+    Uses a deterministic greedy algorithm (no random, reproducible).
+    """
+    names   = [p["name"] for p in pillars]
+    weights = [p.get("weight", 1) for p in pillars]
+    total_w = sum(weights)
+
+    # Target proportion per pillar
+    targets = [w / total_w for w in weights]
+
+    sequence = []
+    counts   = [0] * len(pillars)
+
+    for _ in range(length):
+        # Pick pillar most "behind" its target proportion
+        scores = []
+        for i, name in enumerate(names):
+            current_prop = counts[i] / (len(sequence) + 1) if sequence else 0
+            scores.append(targets[i] - current_prop)
+        best = scores.index(max(scores))
+        sequence.append(names[best])
+        counts[best] += 1
+
+    return sequence
+
+
+# ---------------------------------------------------------------------------
+# Calendar builder
+# ---------------------------------------------------------------------------
+
+def next_monday(from_date: date = None) -> date:
+    d = from_date or date.today()
+    days_ahead = (0 - d.weekday()) % 7
+    if days_ahead == 0:
+        days_ahead = 7
+    return d + timedelta(days=days_ahead)
+
+
+def parse_date(s: str) -> date:
+    return date.fromisoformat(s)
+
+
+def build_calendar(config: dict) -> dict:
+    pillars   = config.get("pillars", DEMO_CONFIG["pillars"])
+    platforms = config.get("platforms", DEMO_CONFIG["platforms"])
+    weeks     = config.get("weeks", 4)
+
+    start_raw = config.get("start_date")
+    if start_raw:
+        start = parse_date(start_raw)
+    else:
+        start = next_monday()
+
+    pillar_map = {p["name"]: p for p in pillars}
+
+    # Pre-compute total posts per platform
+    calendar_by_platform = {}
+
+    for platform in platforms:
+        pname     = platform["name"]
+        ppw       = platform.get("posts_per_week", 3)
+        best_days = platform.get("best_days", WEEKDAY_NAMES[:5])
+
+        # Generate post dates across the period
+        post_dates = []
+        for week in range(weeks):
+            week_start = start + timedelta(weeks=week)
+            day_count  = 0
+            for day_offset in range(7):
+                if day_count >= ppw:
+                    break
+                d      = week_start + timedelta(days=day_offset)
+                d_name = WEEKDAY_NAMES[d.weekday()]
+                if d_name in best_days:
+                    post_dates.append(d)
+                    day_count += 1
+
+        total_posts = len(post_dates)
+        pillar_seq  = build_pillar_sequence(pillars, total_posts)
+
+        posts = []
+        for i, (post_date, pillar_name) in enumerate(zip(post_dates, pillar_seq)):
+            pillar  = pillar_map[pillar_name]
+            hints   = CONTENT_TYPE_HINTS.get(pillar_name, ["Post"])
+            ct_hint = hints[i % len(hints)]
+            posts.append({
+                "date":         post_date.isoformat(),
+                "weekday":      WEEKDAY_NAMES[post_date.weekday()],
+                "week_number":  (post_date - start).days // 7 + 1,
+                "platform":     pname,
+                "pillar":       pillar_name,
+                "pillar_emoji": pillar.get("emoji", ""),
+                "description":  pillar.get("description", ""),
+                "content_type": ct_hint,
+                "content_type_hint": platform.get("content_type_hint", ""),
+            })
+
+        # Pillar distribution stats
+        dist = defaultdict(int)
+        for p in posts:
+            dist[p["pillar"]] += 1
+        dist_pct = {k: round(v / total_posts * 100) for k, v in dist.items()}
+
+        calendar_by_platform[pname] = {
+            "platform":            pname,
+            "posts_per_week":      ppw,
+            "total_weeks":         weeks,
+            "total_posts":         total_posts,
+            "best_days":           best_days,
+            "posts":               posts,
+            "pillar_distribution": dict(dist),
+            "pillar_pct":          dist_pct,
+        }
+
+    # Global summary
+    all_posts = []
+    for pc in calendar_by_platform.values():
+        all_posts.extend(pc["posts"])
+    all_posts.sort(key=lambda p: (p["date"], p["platform"]))
+
+    return {
+        "meta": {
+            "start_date":     start.isoformat(),
+            "end_date":       (start + timedelta(weeks=weeks) - timedelta(days=1)).isoformat(),
+            "weeks":          weeks,
+            "platforms":      [p["name"] for p in platforms],
+            "total_posts":    len(all_posts),
+            "pillars":        [p["name"] for p in pillars],
+        },
+        "platforms": calendar_by_platform,
+        "timeline":  all_posts,   # merged, date-sorted
+    }
+
+
+# ---------------------------------------------------------------------------
+# Markdown output
+# ---------------------------------------------------------------------------
+
+def build_markdown(result: dict) -> str:
+    m = result["meta"]
+    lines = []
+    lines.append(f"# Social Media Content Calendar")
+    lines.append(f"**Period:** {m['start_date']} → {m['end_date']}  "
+                 f"| **{m['weeks']} weeks** | **{m['total_posts']} total posts**\n")
+
+    # Per-platform distribution
+    for pname, pc in result["platforms"].items():
+        lines.append(f"## {pname}  ({pc['total_posts']} posts)\n")
+        lines.append("**Pillar distribution:**")
+        for pillar, count in pc["pillar_distribution"].items():
+            pct = pc["pillar_pct"][pillar]
+            lines.append(f"- {pillar}: {count} posts ({pct}%)")
+        lines.append("")
+
+    # Weekly calendar tables
+    for week_num in range(1, m["weeks"] + 1):
+        lines.append(f"## Week {week_num}\n")
+        header = "| Date | Day | " + " | ".join(m["platforms"]) + " |"
+        sep    = "|---|---|" + "|".join(["---"] * len(m["platforms"])) + "|"
+        lines.append(header)
+        lines.append(sep)
+
+        # Group by date
+        week_posts = defaultdict(dict)
+        for post in result["timeline"]:
+            if post["week_number"] == week_num:
+                week_posts[post["date"]][post["platform"]] = post
+
+        for day_date in sorted(week_posts.keys()):
+            day_posts = week_posts[day_date]
+            weekday   = list(day_posts.values())[0]["weekday"] if day_posts else ""
+            cells     = []
+            for pname in m["platforms"]:
+                if pname in day_posts:
+                    p    = day_posts[pname]
+                    cell = f"{p['pillar_emoji']} **{p['pillar']}**<br/>{p['content_type']}"
+                else:
+                    cell = "—"
+                cells.append(cell)
+            lines.append(f"| {day_date} | {weekday} | " + " | ".join(cells) + " |")
+
+        lines.append("")
+
+    # Legend
+    lines.append("## Content Pillars\n")
+    for pc in result["platforms"].values():
+        break
+    from_meta = result["meta"]["pillars"]
+    lines.append("| Pillar | Description |")
+    lines.append("|---|---|")
+    for pname, pc in result["platforms"].items():
+        # Get pillar descriptions from first platform's posts
+        pillar_desc = {}
+        for post in pc["posts"]:
+            pillar_desc[post["pillar"]] = post["description"]
+        for pillar in from_meta:
+            desc = pillar_desc.get(pillar, "")
+            lines.append(f"| {pillar} | {desc} |")
+        break
+
+    lines.append("")
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Pretty terminal output
+# ---------------------------------------------------------------------------
+
+def pretty_print(result: dict) -> None:
+    m = result["meta"]
+    print("\n" + "=" * 70)
+    print("  📅  SOCIAL MEDIA CONTENT CALENDAR GENERATOR")
+    print("=" * 70)
+    print(f"\n  Period     : {m['start_date']} → {m['end_date']}  ({m['weeks']} weeks)")
+    print(f"  Platforms  : {', '.join(m['platforms'])}")
+    print(f"  Total posts: {m['total_posts']}")
+    print(f"  Pillars    : {', '.join(m['pillars'])}")
+
+    for pname, pc in result["platforms"].items():
+        print(f"\n  {'─'*60}")
+        print(f"  📣  {pname.upper()}  — {pc['total_posts']} posts  "
+              f"({pc['posts_per_week']}/week)")
+        print(f"  Best days: {', '.join(pc['best_days'])}")
+        print(f"  Pillar distribution:")
+        for pillar, count in pc["pillar_distribution"].items():
+            pct = pc["pillar_pct"][pillar]
+            bar = "█" * (pct // 5) + "░" * (20 - pct // 5)
+            print(f"    {pillar:<16}  {count:>3} posts  {pct:>3}%  {bar}")
+
+    print(f"\n  {'─'*70}")
+    print(f"  📆  WEEKLY SCHEDULE\n")
+
+    # Group timeline by week
+    from collections import defaultdict
+    weeks_data = defaultdict(list)
+    for post in result["timeline"]:
+        weeks_data[post["week_number"]].append(post)
+
+    for week_num in sorted(weeks_data.keys()):
+        print(f"  WEEK {week_num}")
+        print(f"  {'Date':<12} {'Day':<11}" +
+              "".join(f" {p:<22}" for p in m["platforms"]))
+        print("  " + "─" * (12 + 11 + 23 * len(m["platforms"])))
+
+        # Group by date
+        day_map = defaultdict(dict)
+        for post in weeks_data[week_num]:
+            day_map[post["date"]][post["platform"]] = post
+
+        for day_date in sorted(day_map.keys()):
+            dp      = day_map[day_date]
+            weekday = list(dp.values())[0]["weekday"]
+            row     = f"  {day_date:<12} {weekday:<11}"
+            for pname in m["platforms"]:
+                if pname in dp:
+                    p    = dp[pname]
+                    cell = f"{p['pillar_emoji']} {p['pillar'][:10]}/{p['content_type'][:8]}"
+                else:
+                    cell = "—"
+                row += f" {cell:<22}"
+            print(row)
+        print()
+
+    print("  💡  TIP: Re-run with --markdown to export a copyable Markdown table.\n")
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Generate a social media content calendar with balanced pillar distribution.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    parser.add_argument("--config",   type=str, default=None,
+                        help="Path to JSON config file")
+    parser.add_argument("--start",    type=str, default=None,
+                        help="Start date YYYY-MM-DD (overrides config)")
+    parser.add_argument("--weeks",    type=int, default=None,
+                        help="Number of weeks to generate (overrides config)")
+    parser.add_argument("--json",     action="store_true",
+                        help="Output calendar as JSON")
+    parser.add_argument("--markdown", action="store_true",
+                        help="Output calendar as Markdown")
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    if args.config:
+        with open(args.config) as f:
+            config = json.load(f)
+    else:
+        print("🔬  DEMO MODE — using sample config (4 pillars, 2 platforms)\n",
+              file=sys.stderr)
+        config = dict(DEMO_CONFIG)
+
+    # CLI overrides
+    if args.start:
+        config["start_date"] = args.start
+    if args.weeks:
+        config["weeks"] = args.weeks
+
+    result = build_calendar(config)
+
+    if args.json:
+        print(json.dumps(result, indent=2, default=str))
+    elif args.markdown:
+        print(build_markdown(result))
+    else:
+        pretty_print(result)
+
+
+if __name__ == "__main__":
+    main()

package/skills/jarvis/engineering-team/marketing-skill/x-twitter-growth/SKILL.md

@@ -0,0 +1,226 @@
+---
+name: "x-twitter-growth"
+description: "X/Twitter growth engine for building audience, crafting viral content, and analyzing engagement. Use when the user wants to grow on X/Twitter, write tweets or threads, analyze their X profile, research competitors on X, plan a posting strategy, or optimize engagement. Complements social-content (generic multi-platform) with X-specific depth: algorithm mechanics, thread engineering, reply strategy, profile optimization, and competitive intelligence via web search."
+license: MIT
+metadata:
+  version: 1.0.0
+  author: Alireza Rezvani
+  category: marketing
+  updated: 2026-03-10
+---
+
+# X/Twitter Growth Engine
+
+X-specific growth skill. For general social media content across platforms, see `social-content`. For social strategy and calendar planning, see `social-media-manager`. This skill goes deep on X.
+
+## When to Use This vs Other Skills
+
+| Need | Use |
+|------|-----|
+| Write a tweet or thread | **This skill** |
+| Plan content across LinkedIn + X + Instagram | social-content |
+| Analyze engagement metrics across platforms | social-media-analyzer |
+| Build overall social strategy | social-media-manager |
+| X-specific growth, algorithm, competitive intel | **This skill** |
+
+---
+
+## Step 1 — Profile Audit
+
+Before any growth work, audit the current X presence. Run `scripts/profile_auditor.py` with the handle, or manually assess:
+
+### Bio Checklist
+- [ ] Clear value proposition in first line (who you help + how)
+- [ ] Specific niche — not "entrepreneur | thinker | builder"
+- [ ] Social proof element (followers, title, metric, brand)
+- [ ] CTA or link (newsletter, product, site)
+- [ ] No hashtags in bio (signals amateur)
+
+### Pinned Tweet
+- [ ] Exists and is less than 30 days old
+- [ ] Showcases best work or strongest hook
+- [ ] Has clear CTA (follow, subscribe, read)
+
+### Recent Activity (last 30 posts)
+- [ ] Posting frequency: minimum 1x/day, ideal 3-5x/day
+- [ ] Mix of formats: tweets, threads, replies, quotes
+- [ ] Reply ratio: >30% of activity should be replies
+- [ ] Engagement trend: improving, flat, or declining
+
+Run: `python3 scripts/profile_auditor.py --handle @username`
+
+---
+
+## Step 2 — Competitive Intelligence
+
+Research competitors and successful accounts in your niche using web search.
+
+### Process
+1. Search `site:x.com "topic" min_faves:100` via Brave to find high-performing content
+2. Identify 5-10 accounts in your niche with strong engagement
+3. For each, analyze: posting frequency, content types, hook patterns, engagement rates
+4. Run: `python3 scripts/competitor_analyzer.py --handles @acc1 @acc2 @acc3`
+
+### What to Extract
+- **Hook patterns** — How do top posts start? Question? Bold claim? Statistic?
+- **Content themes** — What 3-5 topics get the most engagement?
+- **Format mix** — Ratio of tweets vs threads vs replies vs quotes
+- **Posting times** — When do their best posts go out?
+- **Engagement triggers** — What makes people reply vs like vs retweet?
+
+---
+
+## Step 3 — Content Creation
+
+### Tweet Types (ordered by growth impact)
+
+#### 1. Threads (highest reach, highest follow conversion)
+```
+Structure:
+- Tweet 1: Hook — must stop the scroll in <7 words
+- Tweet 2: Context or promise ("Here's what I learned:")
+- Tweets 3-N: One idea per tweet, each standalone-worthy
+- Final tweet: Summary + explicit CTA ("Follow @handle for more")
+- Reply to tweet 1: Restate hook + "Follow for more [topic]"
+
+Rules:
+- 5-12 tweets optimal (under 5 feels thin, over 12 loses people)
+- Each tweet should make sense if read alone
+- Use line breaks for readability
+- No tweet should be a wall of text (3-4 lines max)
+- Number the tweets or use "↓" in tweet 1
+```
+
+#### 2. Atomic Tweets (breadth, impression farming)
+```
+Formats that work:
+- Observation: "[Thing] is underrated. Here's why:"
+- Listicle: "10 tools I use daily:\n\n1. X — for Y"
+- Contrarian: "Unpopular opinion: [statement]"
+- Lesson: "I [did X] for [time]. Biggest lesson:"
+- Framework: "[Concept] explained in 30 seconds:"
+
+Rules:
+- Under 200 characters gets more engagement
+- One idea per tweet
+- No links in tweet body (kills reach — put link in reply)
+- Question tweets drive replies (algorithm loves replies)
+```
+
+#### 3. Quote Tweets (authority building)
+```
+Formula: Original tweet + your unique take
+- Add data the original missed
+- Provide counterpoint or nuance
+- Share personal experience that validates/contradicts
+- Never just say "This" or "So true"
+```
+
+#### 4. Replies (network growth, fastest path to visibility)
+```
+Strategy:
+- Reply to accounts 2-10x your size
+- Add genuine value, not "great post!"
+- Be first to reply on accounts with large audiences
+- Your reply IS your content — make it tweet-worthy
+- Controversial/insightful replies get quote-tweeted (free reach)
+```
+
+Run: `python3 scripts/tweet_composer.py --type thread --topic "your topic" --audience "your audience"`
+
+---
+
+## Step 4 — Algorithm Mechanics
+
+### What X rewards (2025-2026)
+| Signal | Weight | Action |
+|--------|--------|--------|
+| Replies received | Very high | Write reply-worthy content (questions, debates) |
+| Time spent reading | High | Threads, longer tweets with line breaks |
+| Profile visits from tweet | High | Curiosity gaps, tease expertise |
+| Bookmarks | High | Tactical, save-worthy content (lists, frameworks) |
+| Retweets/Quotes | Medium | Shareable insights, bold takes |
+| Likes | Low-medium | Easy agreement, relatable content |
+| Link clicks | Low (penalized) | Never put links in tweet body — use reply |
+
+### What kills reach
+- Links in tweet body (put in first reply instead)
+- Editing tweets within 30 min of posting
+- Posting and immediately going offline (no early engagement)
+- More than 2 hashtags
+- Tagging people who don't engage back
+- Threads with inconsistent quality (one weak tweet tanks the whole thread)
+
+### Optimal Posting Cadence
+| Account size | Tweets/day | Threads/week | Replies/day |
+|-------------|------------|--------------|-------------|
+| < 1K followers | 2-3 | 1-2 | 10-20 |
+| 1K-10K | 3-5 | 2-3 | 5-15 |
+| 10K-50K | 3-7 | 2-4 | 5-10 |
+| 50K+ | 2-5 | 1-3 | 5-10 |
+
+---
+
+## Step 5 — Growth Playbook
+
+### Week 1-2: Foundation
+1. Optimize bio and pinned tweet (Step 1)
+2. Identify 20 accounts in your niche to engage with daily
+3. Reply 10-20 times per day to larger accounts (genuine value only)
+4. Post 2-3 atomic tweets per day testing different formats
+5. Publish 1 thread
+
+### Week 3-4: Pattern Recognition
+1. Review what formats got most engagement
+2. Double down on top 2 content formats
+3. Increase to 3-5 posts per day
+4. Publish 2-3 threads per week
+5. Start quote-tweeting relevant content daily
+
+### Month 2+: Scale
+1. Develop 3-5 recurring content series (e.g., "Friday Framework")
+2. Cross-pollinate: repurpose threads as LinkedIn posts, newsletter content
+3. Build reply relationships with 5-10 accounts your size (mutual engagement)
+4. Experiment with spaces/audio if relevant to niche
+5. Run: `python3 scripts/growth_tracker.py --handle @username --period 30d`
+
+---
+
+## Step 6 — Content Calendar Generation
+
+Run: `python3 scripts/content_planner.py --niche "your niche" --frequency 5 --weeks 2`
+
+Generates a 2-week posting plan with:
+- Daily tweet topics with hook suggestions
+- Thread outlines (2-3 per week)
+- Reply targets (accounts to engage with)
+- Optimal posting times based on niche
+
+---
+
+## Scripts
+
+| Script | Purpose |
+|--------|---------|
+| `scripts/profile_auditor.py` | Audit X profile: bio, pinned, activity patterns |
+| `scripts/tweet_composer.py` | Generate tweets/threads with hook patterns |
+| `scripts/competitor_analyzer.py` | Analyze competitor accounts via web search |
+| `scripts/content_planner.py` | Generate weekly/monthly content calendars |
+| `scripts/growth_tracker.py` | Track follower growth and engagement trends |
+
+## Common Pitfalls
+
+1. **Posting links directly** — Always put links in the first reply, never in the tweet body
+2. **Thread tweet 1 is weak** — If the hook doesn't stop scrolling, nothing else matters
+3. **Inconsistent posting** — Algorithm rewards daily consistency over occasional bangers
+4. **Only broadcasting** — Replies and engagement are 50%+ of growth, not just posting
+5. **Generic bio** — "Helping people do things" tells nobody anything
+6. **Copying formats without adapting** — What works for tech Twitter doesn't work for marketing Twitter
+
+## Related Skills
+
+- `social-content` — Multi-platform content creation
+- `social-media-manager` — Overall social strategy
+- `social-media-analyzer` — Cross-platform analytics
+- `content-production` — Long-form content that feeds X threads
+- `copywriting` — Headline and hook writing techniques

package/skills/jarvis/engineering-team/marketing-skill/x-twitter-growth/references/algorithm-signals.md

@@ -0,0 +1,70 @@
+# X/Twitter Algorithm Signals (2025-2026)
+
+## Ranking Factors by Weight
+
+### Tier 1 — Strongest Signals
+| Signal | Impact | How to Optimize |
+|--------|--------|----------------|
+| Replies received | Very high | Ask questions, make controversial/insightful points |
+| Dwell time (time reading) | Very high | Threads, longer tweets with line breaks |
+| Profile clicks from tweet | High | Create curiosity gaps, tease expertise |
+| Bookmarks | High | Tactical content (lists, frameworks, templates) |
+
+### Tier 2 — Moderate Signals
+| Signal | Impact | How to Optimize |
+|--------|--------|----------------|
+| Retweets/Quotes | Medium | Shareable insights, bold takes, data |
+| Likes | Medium-low | Easy agreement, relatable content |
+| Follows from tweet | Medium | Thread CTAs, high-value niche content |
+
+### Tier 3 — Negative Signals
+| Signal | Impact | How to Avoid |
+|--------|--------|-------------|
+| Link in tweet body | Reach penalty | Put links in first reply |
+| Edit within 30 min | Suppresses | Don't edit — delete and repost if needed |
+| Low early engagement | Decay | Stay online 30 min after posting, engage with replies |
+| Hashtag spam (3+) | Spam signal | Max 1-2 hashtags, or zero |
+| Tagging non-engagers | Negative | Only tag people likely to engage |
+
+## Content Format Performance (ranked)
+
+1. **Threads** — Highest reach potential, best for follower conversion
+2. **Image tweets** — 2-3x engagement vs text-only
+3. **Quote tweets** — Network effect (appear in two audiences)
+4. **Text tweets** — Baseline, best for hot takes and questions
+5. **Polls** — High engagement but low follower conversion
+6. **Link tweets** — Lowest reach (algorithm penalizes external links)
+
+## Optimal Timing
+
+| Time Slot (UTC) | Why |
+|----------------|-----|
+| 12:00-14:00 | US East Coast morning, EU afternoon |
+| 16:00-18:00 | US afternoon peak |
+| 21:00-23:00 | US evening, high scroll time |
+| 07:00-08:00 | EU morning, commute scrolling |
+
+Best days: Tuesday-Thursday for B2B. Saturday-Sunday for consumer/lifestyle.
+
+## Thread-Specific Mechanics
+
+- Tweet 1 gets 10-50x the impressions of tweet 5+
+- Hook quality determines 90% of thread performance
+- "Numbered" threads (1/, 2/, etc.) signal commitment — algorithm boosts
+- Self-reply threads perform better than tweetstorm threads
+- Last tweet should have CTA + restate hook for people who scroll fast
+
+## Premium/Blue Subscriber Advantages
+
+- Longer tweets (up to 4,000 chars for Premium+)
+- Edit button (use sparingly — edits can suppress reach)
+- Higher reply ranking
+- Revenue sharing eligibility
+- Analytics access
+
+## Sources
+
+- X Engineering Blog (algorithm open-source release, 2023)
+- Community testing and experimentation (ongoing)
+- Creator program documentation
+- Third-party analytics platforms (Typefully, Hypefury, Shield)