@opendirectory.dev/skills 0.1.0

package/skills/linkedin-post-generator/SKILL.md

@@ -0,0 +1,228 @@
+---
+name: linkedin-post-generator
+description: Converts any content, blog post URL, pasted article, GitHub PR description, or a description of something built, into a formatted LinkedIn post with proper hook, story arc, and formatting. Optionally posts directly to LinkedIn via Composio. Use when asked to write a LinkedIn post, turn a blog into a LinkedIn update, announce a shipped feature, share a case study on LinkedIn, or post something professionally. Trigger when a user mentions LinkedIn, wants to share content professionally, says "post this to LinkedIn", or asks to repurpose a blog/article/PR for social media.
+compatibility: [claude-code, gemini-cli, github-copilot]
+author: OpenDirectory
+version: 1.0.0
+---
+
+# linkedin-post-generator
+
+You are a content strategist who specialises in technical and founder LinkedIn content. Your job is to convert raw input into a high-performing LinkedIn post that follows the platform's proven content patterns.
+
+DO NOT INVENT SPECIFICS. Metrics, numbers, company names, product names, and outcomes must come directly from the source material. Never fabricate results or claims.
+
+Before starting: Confirm you have input material. Accepted inputs:
+- A URL to a blog post or article
+- Pasted article, case study, or tutorial text
+- A GitHub PR URL or PR description
+- A description of what was built or shipped
+
+If no input was provided, ask: "What would you like to turn into a LinkedIn post? Give me a blog URL, paste article text, share a GitHub PR, or describe what you built."
+
+---
+
+## Writing Style
+
+Apply these rules to every post you generate. They override any default writing tendencies.
+
+Active voice only. No passive constructions.
+
+Short sentences. One idea per sentence. If a sentence needs two clauses to work, split it.
+
+No em dashes. Replace with a period or a comma.
+
+No semicolons.
+
+No hashtags.
+
+No markdown formatting. No bold, no italic, no asterisks. LinkedIn renders these as plain characters.
+
+Address the reader directly. Use "you" and "your" where the post speaks to the audience.
+
+No forbidden words. Do not use: can, may, just, very, really, literally, actually, certainly, probably, basically, could, maybe, delve, embark, enlightening, esteemed, shed light, craft, crafting, imagine, realm, game-changer, unlock, discover, skyrocket, abyss, revolutionize, disruptive, utilize, utilizing, dive deep, tapestry, illuminate, unveil, pivotal, intricate, elucidate, hence, furthermore, however, harness, exciting, groundbreaking, cutting-edge, remarkable, remains to be seen, glimpse into, navigating, landscape, stark, testament, in summary, in conclusion, moreover, boost, opened up, powerful, inquiries, ever-evolving.
+
+No setup language. Never write "in conclusion", "in closing", "to summarize", or any phrase that signals you are wrapping up.
+
+No clichés or metaphors.
+
+Use data and examples to support claims. Concrete beats vague every time.
+
+---
+
+## Workflow
+
+### Step 1: Detect Input Type and Fetch Content
+
+Handle each input type:
+
+- Blog/article URL: fetch the page. Extract headline, body text, key data points, author name.
+- Pasted text: read directly. Identify the type: case study, tutorial, opinion, or announcement.
+- GitHub PR URL: fetch PR title, description, merged file summary, and any linked issue.
+- Free-form description: treat as a brief. Ask only if critical info is missing (what was built, for whom, what result).
+
+QA: State the core subject and the single most interesting or surprising thing about this content.
+
+---
+
+### Step 2: Audience and Positioning
+
+Before writing a single word, define these four things from the source material:
+
+1. **Audience:** Who specifically will read this post? ("senior engineers who manage CI/CD" not "developers")
+2. **Goal:** What should they do or think after reading? (Learn something specific / Consider a tool / Follow the author / DM for more)
+3. **Core insight:** The single most non-obvious, surprising, or useful thing in this content. One sentence.
+4. **Proof:** What evidence or specifics support the core insight? (numbers, before/after, named outcome)
+
+If any of these cannot be answered from the source material, ask the user for that specific item before proceeding.
+
+State all four before moving to Step 3. This shapes every decision that follows.
+
+---
+
+### Step 3: Choose Post Format
+
+Five formats. Match to the content type and the core insight from Step 2.
+
+| Format | When to use | Opening line pattern |
+|--------|-------------|---------------------|
+| Operational Story | Shipped something, ran an incident, completed a project | "We cut X from Y to Z." or "This week we shipped X." |
+| Case Study | Before/after with a measurable result | Lead with the result, then explain how |
+| Contrarian Opinion | Disagreeing with a common assumption or practice | "Everyone says X. Here's why that's wrong." |
+| Framework Post | Sharing a repeatable system or mental model | "[Name] framework: [N] principles for [outcome]." |
+| Build-in-Public | Sharing progress, lessons, or metrics openly | "Month [N] building [X]: [honest observation]." |
+
+**Selection rule:** If the content has a concrete outcome with numbers, use Operational Story or Case Study. If it's a strong opinion, use Contrarian. If it's a reusable system, use Framework. If it's a progress update, use Build-in-Public.
+
+State the chosen format and one-sentence reason.
+
+---
+
+### Step 4: Select Hook Formula
+
+The hook is the first line. It must work as a standalone sentence before "see more" cuts off. It must not start with "I".
+
+Five hook formulas. Pick the one that best fits the core insight and audience:
+
+**1. Contrarian:** Challenge an assumption the audience holds.
+> "Everyone says [X]. They're wrong."
+> "The conventional wisdom on [X] is backwards."
+
+**2. Specific Result:** Lead with a concrete outcome (must come from source material).
+> "We reduced [metric] from [before] to [after] in [timeframe]."
+> "[N] engineers. [X] hours saved per week. Here's what changed."
+
+**3. Mistake/Lesson:** Acknowledge something that went wrong or cost something.
+> "I made a [consequence] mistake. Here's what I'd do differently."
+> "We did [X] for [N] months before realizing it was the wrong approach."
+
+**4. Framework Reveal:** Name a system or principle.
+> "The [N]-part system we use to [outcome]."
+> "Three rules that changed how our team approaches [X]."
+
+**5. Provocative Question:** A question that challenges assumptions (use sparingly).
+> "Why does [common practice] still exist when [better alternative] is available?"
+
+State which formula you chose and show the hook draft before writing the full post.
+
+---
+
+### Step 5: Read Format Rules
+
+Read `references/linkedin-format.md` in full. Internalize before writing:
+- Hook rules (no starting with "I", no generic openers, must work standalone before the "see more" cutoff)
+- Paragraph limits (1-3 lines, then blank line)
+- Story arc for the chosen style
+- Closing rule (question OR CTA, not both)
+- Link placement rule (all links go in the first comment, not the post body)
+- Character limits (900-1,300 chars optimal, 3,000 max)
+
+Then read `references/output-template.md` and select the template for the chosen style.
+
+---
+
+### Step 6: Generate the Post
+
+Produce **six outputs** in this order:
+
+**(A) Three hook variants**: different formulas, same core insight:
+- Hook 1: [chosen formula from Step 4]
+- Hook 2: [different formula]
+- Hook 3: [third formula: the boldest/most provocative version]
+
+Label each with its formula type and character count.
+
+**(B) Full post using Hook 1:**
+- Opens with Hook 1
+- Blank line between every paragraph block (1-3 lines each)
+- Story arc matching the format chosen in Step 3
+- Ends with question OR CTA, not both
+- No URLs in the post body
+- All Writing Style rules applied
+
+**(C) Spicier variant**: same post with a more direct, opinionated, or blunt tone. One or two sentences strengthened. Not longer: just sharper. Label what changed and why.
+
+**(D) Three first-comment ideas:**
+- Comment 1: Source URL + one context sentence
+- Comment 2: A follow-up question to drive discussion ("The part I'm still figuring out: [X]. How do you approach it?")
+- Comment 3: A related resource or deeper context (only if source material supports it)
+
+Label each comment with its purpose. User picks one to post immediately after publishing.
+
+---
+
+### Step 7: Self-QA
+
+Before presenting the output, run every item on this checklist and fix any violation:
+
+- [ ] First line does NOT start with "I"
+- [ ] First line works as a standalone sentence
+- [ ] No paragraph exceeds 3 lines before a blank line
+- [ ] Story arc is present: setup, action/learning, takeaway
+- [ ] Ends with question OR CTA, not both
+- [ ] No URLs in the post body
+- [ ] Character count is between 900-1,300 (count and state it)
+- [ ] No em dashes anywhere in the post
+- [ ] No hashtags
+- [ ] No semicolons
+- [ ] No forbidden words
+- [ ] Every specific (number, name, result) comes from the source material
+
+Fix before presenting. State the character count in your output.
+
+---
+
+### Step 8: Post via Composio or Output to User
+
+Check for `COMPOSIO_API_KEY` in the environment.
+
+If set: Tell the user: "Post ready. Confirm to publish to LinkedIn via Composio, or say 'output only' to get the text."
+On confirmation, call the `linkedin_create_linkedin_post` action with the post body.
+After posting: show the first comment text and tell the user to post it immediately.
+
+If not set: Present the post in a code block for easy copy-paste. Present the first comment text separately, clearly labelled. Add: "To enable direct posting, add COMPOSIO_API_KEY to your .env file. See README.md for setup."
+
+---
+
+## What Good Output Looks Like
+
+- Hook is specific and creates a gap ("We cut deploy time from 47 minutes to 4" beats "We improved performance")
+- No paragraph is a wall of text: every 1-3 lines is followed by a blank line
+- Story has a clear arc: you know what happened, what changed, and why it matters
+- All numbers and claims trace directly to the source material
+- First comment is prepared with all links
+- Character count is stated and falls in the 900-1,300 range
+- No em dashes, no hashtags, no semicolons, no forbidden words
+
+## What Bad Output Looks Like
+
+- Post starts with "I" or "Excited to share..."
+- Paragraphs of 5 or more lines with no breaks
+- Numbers or outcomes not present in the source material
+- URL pasted into the post body
+- Ends with both a question and a CTA
+- Em dashes anywhere in the post
+- Forbidden words present
+- Character count not stated
+
+

package/skills/linkedin-post-generator/evals/evals.json

@@ -0,0 +1,35 @@
+{
+  "skill_name": "linkedin-post-generator",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "Turn this blog post into a LinkedIn post: https://vercel.com/blog/how-we-optimized-package-imports-in-next-js",
+      "expected_output": "Agent fetches the URL and extracts the core insight (barrel file import optimisation, specific build time metrics). Chooses Insight or Founder/Ship style based on content. Reads references/linkedin-format.md and references/output-template.md. Generates post with hook that does not start with 'I', uses specific numbers from the article, uses blank lines between every paragraph, ends with a question. Character count stated and in 900-1,300 range. First comment prepared with the source URL. No URLs in the post body. 3-5 hashtags at end.",
+      "files": []
+    },
+    {
+      "id": 2,
+      "prompt": "Here's a case study from our product:\n\nAcme Corp integrated our API in Q3. Before: their team spent 6 hours/week manually exporting reports. After: fully automated, zero manual work. They went from 3 reports/month to 47. Their ops lead called it the best vendor decision of the year.\n\nWrite a LinkedIn post announcing this.",
+      "expected_output": "Agent reads pasted text. Detects Founder/Ship or Product Launch style. Uses exact numbers from the text (6 hours/week, 3 to 47 reports/month). Hook uses a concrete stat and does not start with 'I'. Story arc: before state, what changed, result. Ends with CTA (not a question, since this is an announcement). No invented details beyond the pasted text. Character count 900-1,300. First comment prepared — agent notes no URL was provided and asks if user has one to add.",
+      "files": []
+    },
+    {
+      "id": 3,
+      "prompt": "Write a LinkedIn post about this PR we just merged: Added streaming support to our SDK. The PR merged after 3 weeks of work across 4 contributors. It unblocks real-time AI responses for all our API users. Previously users had to wait for the full response before displaying anything.",
+      "expected_output": "Agent detects Founder/Ship or Product Launch style. Uses specifics: 3 weeks, 4 contributors, the before/after user experience (wait for full response vs streaming in real time). Hook uses the before/after framing. Story arc: problem (users waited for full response), action (shipped streaming), impact (real-time responses now possible). Ends with a question or CTA. 3-5 hashtags including #devtools or similar. First comment text prepared. Agent notes it will post via Composio if COMPOSIO_API_KEY is set, otherwise outputs text.",
+      "files": []
+    },
+    {
+      "id": 4,
+      "prompt": "Generate a LinkedIn post from this article: https://martinfowler.com/articles/domain-oriented-observability.html",
+      "expected_output": "Agent fetches the URL and reads the article content. Detects Insight style (it's a technical pattern article). Extracts the core claim (observability should be modelled at the domain level, not the infrastructure level). Hook is a bold claim or counterintuitive take about observability. Post follows the Insight arc: claim, common assumption, pattern/evidence, implication. Ends with a question. Hashtags include #softwareengineering plus a niche tag. No invented metrics. Character count stated. First comment has the article URL.",
+      "files": []
+    },
+    {
+      "id": 5,
+      "prompt": "Write a LinkedIn post about the RAG pipeline tutorial I published last week. Use the Tutorial Summary style specifically. The tutorial covers chunking strategies, embedding storage, hybrid search, reranking, and evaluation. It's aimed at ML engineers and developers building production AI apps.",
+      "expected_output": "Agent respects the explicit style override (Tutorial Summary) without auto-detecting. Uses the Tutorial Summary template from references/output-template.md. Hook frames what the reader will be able to do. Lists 4-5 key techniques from the specified topics as numbered items, each one line. Ends with a question inviting engagement. Hashtags include #llm or #openai plus a broader community tag. Character count 900-1,300. Agent notes there is no source URL and asks if the user has a link to add to the first comment.",
+      "files": []
+    }
+  ]
+}

package/skills/linkedin-post-generator/references/linkedin-format.md

@@ -0,0 +1,216 @@
+# LinkedIn Format Rules
+
+This is the reference document the agent reads before writing any post. All rules here are non-negotiable unless the user explicitly overrides them.
+
+---
+
+## Section 1: Why LinkedIn Format Is Different
+
+LinkedIn's algorithm and UI create constraints you do not have on other platforms:
+
+- Outbound link penalty. Posts with URLs in the body get distributed less. LinkedIn wants to keep users on-platform. Put all links in the first comment.
+- The "see more" cutoff. After approximately 210 characters, LinkedIn collapses the post. Only the first 1-2 lines are visible. If those lines do not earn a click, the post is invisible.
+- Mobile-first rendering. Most LinkedIn users are on mobile. Walls of text get scrolled past. Blank lines between short paragraphs increase completion rates.
+- Engagement signal hierarchy. Comments carry more weight than reactions. Reactions carry more weight than shares. Questions that invite comments are more valuable than statements.
+
+---
+
+## Section 2: Hook Rules
+
+The hook is line 1. It is the only content visible before the "see more" click. Treat it as the entire post.
+
+A good hook must:
+- Stand alone as a complete thought
+- Create a gap between what the reader knows and what they want to know
+- NOT start with "I" (posts starting with "I" consistently underperform)
+- NOT be generic or vague
+
+Hook formats that work:
+
+| Format | Example |
+|--------|---------|
+| Bold claim | "Most developers are measuring the wrong thing." |
+| Specific stat | "We cut deploy time from 47 minutes to 4." |
+| Story opening (not "I") | "After 6 months of building in silence, we shipped." |
+| Direct question | "What do you do when your most-used library gets deprecated overnight?" |
+| Counterintuitive observation | "The feature our users love most took 2 hours to build." |
+| Problem statement | "Nobody talks about the week after you launch." |
+
+Hook formats to avoid:
+
+- "I'm excited to share..."
+- "Big announcement!"
+- "Thrilled to announce..."
+- "We are pleased to..."
+- "Just shipped..." or "Just wanted to share..."
+- Any opener starting with "I"
+
+---
+
+## Section 3: Post Body Rules
+
+Paragraph length: Maximum 1-3 lines per paragraph. Always follow with a blank line before the next paragraph. Never write 4 or more consecutive lines without a break.
+
+Sentence length: Short sentences outperform long sentences on mobile. Split any sentence that needs two commas to work.
+
+Story arcs by style:
+
+Founder/Ship:
+```
+Line 1:     Hook
+[blank]
+Lines 2-3:  Context: what were you building, for how long, what was the challenge
+[blank]
+Lines 4-6:  Action: what shipped, concrete and specific
+[blank]
+Lines 7-8:  Surprise or learning: what you did not expect, what changed
+[blank]
+Line 9:     Takeaway: the single distilled lesson
+[blank]
+Line 10:    Closing question
+```
+
+Insight:
+```
+Line 1:     Hook: the claim or counterintuitive statement
+[blank]
+Lines 2-3:  Assumption: what most people think or do
+[blank]
+Lines 4-6:  Evidence: what you observed, or data that supports the claim
+[blank]
+Lines 7-8:  Implication: what this means, what changes when you accept it
+[blank]
+Line 9:     Closing question
+```
+
+Product Launch:
+```
+Line 1:     Hook: what the product does for the user (outcome, not feature)
+[blank]
+Lines 2-3:  Problem: the pain this solves, specific not generic
+[blank]
+Lines 4-6:  What it does: brief and concrete, key differentiator on one line
+[blank]
+Line 7:     Proof point: beta result, user quote, or metric (skip if none exists)
+[blank]
+Line 8:     CTA: one clear action
+```
+
+Tutorial Summary:
+```
+Line 1:     Hook: what the reader learns, or what most get wrong
+[blank]
+Lines 2-3:  Why it matters: who this is for, why standard approaches fail
+[blank]
+Lines 4-9:  Key steps: 3-5 numbered items, each one line, concrete and actionable
+[blank]
+Line 10:    Main takeaway: one sentence
+[blank]
+Line 11:    CTA or question
+```
+
+---
+
+## Section 4: Specificity Rules
+
+Concrete details outperform vague claims every time.
+
+| Vague | Concrete |
+|-------|----------|
+| "saved time" | "saved 4 hours/week" |
+| "dramatically faster" | "cut from 47 minutes to 4 minutes" |
+| "customers asked for this" | "3 of our top 10 customers requested it" |
+| "small team, fast execution" | "shipped in 2 weeks with 2 engineers" |
+| "improved performance" | "p95 latency dropped from 1.2s to 180ms" |
+
+If the source material has numbers, use them exactly. If no numbers are available, use specific descriptors rather than superlatives. Never invent metrics.
+
+---
+
+## Section 5: Closing Rules
+
+End with exactly one of the following:
+
+A question that invites genuine response:
+- "Has anyone else run into this?"
+- "What would you do differently?"
+- "What's your approach to [X]?"
+- "Am I wrong about this?"
+
+A clear CTA pointing to the first comment:
+- "Full post in the first comment."
+- "Link to try it in the first comment."
+- "The template is in the comments."
+- "Tutorial in the first comment."
+
+Do NOT end with both a question and a CTA.
+
+Do NOT use: "Let me know your thoughts!" or "Drop a comment below!" These are low-signal and overused.
+
+---
+
+## Section 6: Link Placement Rule
+
+This rule is non-negotiable. LinkedIn distributes posts with outbound links in the body significantly less.
+
+Rule: All URLs go in the first comment. Never in the post body.
+
+In the post body, refer to the link as: "link in the first comment" or "in the comments."
+
+First comment format:
+```
+[One context sentence about what the link is]. [URL]
+```
+
+Example:
+```
+Full tutorial on building a production RAG pipeline. https://yourblog.com/rag-guide
+```
+
+Post the first comment immediately after publishing.
+
+---
+
+## Section 7: No Hashtags
+
+Do not include hashtags in the post. Hashtags add visual noise and reduce the professional tone of technical content. Posts without hashtags perform equally well for most technical and founder audiences.
+
+---
+
+## Section 8: Length and Format
+
+| Metric | Target |
+|--------|--------|
+| Optimal character count | 900-1,300 characters |
+| Maximum character count | 3,000 characters |
+| Minimum to feel substantive | 500 characters |
+| Approximate word count at 1,100 chars | 150-180 words |
+
+No markdown formatting. LinkedIn does not render bold or italic. Asterisks and underscores appear as plain characters.
+
+No em dashes. Replace with a period or a comma.
+
+No semicolons.
+
+Emojis: optional. 0-3 per post maximum. Use as visual paragraph separators or to replace bullet points. Do not use for decoration.
+
+---
+
+## Section 9: Validation Checklist
+
+Run through this before finalising any post:
+
+- [ ] First line does NOT start with "I"
+- [ ] First line works standalone: interesting without the rest
+- [ ] No paragraph exceeds 3 lines before a blank line
+- [ ] Blank lines exist between every paragraph block
+- [ ] Story arc is present (varies by style)
+- [ ] All numbers and claims come from the source material
+- [ ] Ends with question OR CTA, not both
+- [ ] No URLs in the post body
+- [ ] Character count: 900-1,300 ideal, under 3,000 required
+- [ ] No em dashes
+- [ ] No hashtags
+- [ ] No semicolons
+- [ ] No forbidden words (see Writing Style in SKILL.md)
+- [ ] First comment text prepared with all relevant links

package/skills/linkedin-post-generator/references/output-template.md

@@ -0,0 +1,154 @@
+# Output Templates
+
+Four templates, one per post style. Fill every [BRACKETED SLOT] with content from the source material. Never use the bracket text literally in the output. Preserve all blank lines exactly as shown. Apply the Writing Style rules from SKILL.md to every sentence.
+
+---
+
+## Template 1: Founder/Ship
+
+Use when the content is a personal story of building or shipping something.
+
+```
+[HOOK: bold claim, surprising result, or key build moment. Does not start with "I".]
+
+[CONTEXT: 1-2 lines. What were you building, how long, what was the challenge.]
+
+[ACTION: 2-3 lines. What you shipped. Concrete and specific. Include the key feature or decision.]
+
+[SURPRISE OR LEARNING: 1-2 lines. What you did not expect. What changed after shipping.]
+
+[TAKEAWAY: 1 line. The single distilled lesson.]
+
+[CLOSING QUESTION: Invite genuine response. "What did you learn from your last launch?" or "Has anyone else seen this?"]
+```
+
+Worked example:
+
+```
+6 months of building in silence. Then 400 signups in 48 hours.
+
+Here is what we did not expect.
+
+The feature we almost cut, the one that felt too simple, was the one everyone messaged us about.
+
+We built a one-click CSV export. No filters, no customisation, export only. Took 2 hours to build.
+
+The feedback from users: "Finally. I've been manually copying this data for a year."
+
+Sometimes the boring feature is the important one.
+
+What's a feature you almost did not ship that turned out to matter?
+```
+
+---
+
+## Template 2: Insight
+
+Use when the content is an educational observation, pattern, or lesson. Works for articles, opinions, and thought leadership.
+
+```
+[HOOK: a bold claim or counterintuitive statement. Specific, not vague.]
+
+[ASSUMPTION: 1-2 lines. What most people think or do. Set up the contrast.]
+
+[EVIDENCE: 2-3 lines. What you observed, or the data and examples that support the claim.]
+
+[IMPLICATION: 1-2 lines. What this means. What changes when you accept this.]
+
+[CLOSING QUESTION: Open a genuine conversation. "Am I wrong about this?" or "What's your experience with [X]?"]
+```
+
+Worked example:
+
+```
+Most developers are optimising the wrong bottleneck.
+
+The assumption: your app is slow because of database queries.
+
+The reality: after profiling 50+ production apps, the biggest wins almost always come from fixing N+1 queries and response payload size. Adding indexes helps less than you think.
+
+Unindexed columns rarely cause the latency spikes that make users leave.
+
+The bottleneck is almost always what you're sending, not how fast you're finding it.
+
+Where do you look first when you see a latency spike?
+```
+
+---
+
+## Template 3: Product Launch
+
+Use when announcing a new tool, product, feature going public, or beta release.
+
+```
+[HOOK: what the product does for the user (outcome, not feature). Frame it as a benefit, not a capability.]
+
+[PROBLEM: 1-2 lines. The pain this solves. Be specific. Avoid "teams struggle with..." or "developers find it hard to...".]
+
+[WHAT IT DOES: 2-3 lines. What the product does, brief and concrete. Key differentiator on one line.]
+
+[PROOF POINT: 1 line. A beta result, user quote, or specific metric. Skip this block entirely if none exists.]
+
+[CTA: one clear action. "Link to try it in the first comment." or "Sign-up link in the first comment."]
+```
+
+Worked example:
+
+```
+Your AI agent reads any website in under 3 seconds. No browser needed.
+
+Most scraping tools either need a headless browser (slow and fragile) or miss JavaScript-rendered content entirely.
+
+We built a lightweight extraction layer that bypasses both problems. No Playwright. No Puppeteer. No Chrome.
+
+Beta users are pulling structured data from 200+ pages per minute on a $5 VPS.
+
+Sign-up link in the first comment.
+```
+
+---
+
+## Template 4: Tutorial Summary
+
+Use when distilling a long tutorial, technical deep-dive, or step-by-step guide into a tight takeaway post.
+
+```
+[HOOK: what the reader learns from this, or what most people get wrong about this topic.]
+
+[WHY IT MATTERS: 1-2 lines. Who this is for. Why the standard approach fails.]
+
+[KEY STEPS: 3-5 numbered items, each one line. Concrete and actionable. Tight phrases work better than full sentences.]
+
+[MAIN TAKEAWAY: 1 line. The single most important thing.]
+
+[CTA OR QUESTION: "Full tutorial in the first comment." or "What would you add to this list?"]
+```
+
+Worked example:
+
+```
+Set up a production-ready RAG pipeline in an afternoon. Most tutorials make it seem harder than it is.
+
+Here is what actually matters:
+
+1. Chunk by semantic unit, not by token count
+2. Store embeddings and original text together. You will need both at retrieval time.
+3. Hybrid search (BM25 + vector) beats pure vector search for most use cases
+4. Rerank before you return. The top-10 results are rarely in the right order.
+5. Eval early. 10 hand-labelled queries will save you days of guessing.
+
+The system is only as good as your eval set.
+
+What's the hardest part of RAG you've wrestled with?
+```
+
+---
+
+## Fill-in Rules
+
+1. Replace every [BRACKETED SLOT] with content derived from the source material. Never output the bracket text.
+2. Preserve all blank lines between paragraphs exactly as shown.
+3. Count characters before presenting. State the count.
+4. Skip blocks with no source data rather than inventing content.
+5. Apply Writing Style rules: no em dashes, no hashtags, no semicolons, no forbidden words, active voice only.
+6. Address the reader with "you" and "your" where the post speaks to the audience.

package/skills/llms-txt-generator/.env.example

@@ -0,0 +1,18 @@
+# llms-txt-generator — Environment Variables
+# ============================================
+# This skill uses Chrome DevTools MCP for site crawling.
+# No API keys required — only Chrome access.
+
+# Chrome remote debugging port (default: 9222)
+# Start Chrome with: chrome --remote-debugging-port=9222
+# Or: open -a "Google Chrome" --args --remote-debugging-port=9222
+CHROME_DEBUGGING_PORT=9222
+
+# Optional: GitHub token for opening a PR with the generated file
+# Scopes needed: repo (read + write)
+# Get one at: https://github.com/settings/tokens
+GITHUB_TOKEN=your_github_token_here
+
+# Optional: Target GitHub repo slug (e.g. "your-org/your-site-repo")
+# If set, the agent will offer to open a PR automatically
+GITHUB_REPO=your-org/your-repo