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.

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

---

Supporting file: README.md

linkedin-post-generator

<img width="1376" height="768" alt="LinkedIn_post_generator" src="https://github.com/user-attachments/assets/dc71e06b-8b3c-486a-adbf-d56a7b22cdc1" />

Generate LinkedIn posts from any content: blog posts, articles, GitHub PRs, or a description of what you built. The agent reads your source material, applies LinkedIn's content patterns, and produces a post with the right hook, story arc, and formatting.

Install

Option A: npx CLI (Recommended)

No global install. Always runs the latest version.

npx "@opendirectory.dev/skills" install linkedin-post-generator --target claude

Option B: skills.sh

npx skills add Varnan-Tech/opendirectory --skill linkedin-post-generator

Requires Node.js. Add --global to install to ~/.claude/skills/ instead of the current project.

Option C: Claude Desktop App

<video src="https://github.com/user-attachments/assets/cea8b565-2002-4a87-8857-d902bfcfdc1c" controls width="100%"></video>

Step 1: Download the skill from GitHub

1. Copy the URL of this specific skill folder from your browser's address bar.
2. Go to download-directory.github.io (https://download-directory.github.io/).
3. Paste the URL and click Enter to download.

Step 2: Install in Claude

1. Open your Claude desktop app.
2. Go to the sidebar on the left side and click on the Customize section.
3. Click on the Skills tab, then click on the + button to create a new skill.
4. Choose Upload a skill, then drag and drop the .zip file or extracted folder.

Note: For some skills, the SKILL.md file might be located inside a subfolder. Always upload the specific folder that contains the SKILL.md file.

Option D: Claude Code Native

Run these commands inside Claude Code:

/plugin marketplace add Varnan-Tech/opendirectory
/plugin install opendirectory-gtm-skills@opendirectory-marketplace

Option E: Manus AI

<video src="https://github.com/user-attachments/assets/17cbee2a-9e17-4bd4-ac46-68e0e92ffab4" controls width="100%"></video>

Install in Manus AI

Manus AI users can import a skill directly from its OpenDirectory skill page. This is the easiest path when you want Manus to pull the skill from GitHub for you.

1. Open the skill you want from the opendirectory homepage (https://opendirectory.dev).
2. In the install panel, select the Manus AI tab.
3. Click Install in Manus AI - this opens Manus with the skill GitHub URL already attached.
4. Confirm the import inside Manus AI.

If your Manus workspace prefers file uploads, use the Download tab instead and upload the downloaded .skill.zip file inside Manus.

Post Styles

The agent auto-detects the right style. You override it by asking for a specific one.

Requirements

No LLM API key needed. The agent writes the post.

Composio is optional. Add it to post directly to LinkedIn.

Setup

Composio (Optional)

Without Composio, the agent outputs formatted text for copy-paste. No configuration needed.

To enable direct posting:

1. Get your API key at https://app.composio.dev/settings
2. Connect your LinkedIn account at https://app.composio.dev/app/linkedin
3. Complete the OAuth flow
4. Add the key to your .env file:

cp .env.example .env
# Edit .env and add your COMPOSIO_API_KEY

How to Use

From a URL:

"Turn this into a LinkedIn post: https://yourblog.com/my-post"
"Write a LinkedIn post about this article: [URL]"

From pasted text:

"Here's a case study, turn it into a LinkedIn post: [paste text]"
"Convert this to a LinkedIn post: [paste article]"

From a PR or shipped feature:

"Write a LinkedIn post about this PR we merged: [paste PR description]"
"Announce our new feature on LinkedIn: [describe the feature]"

With a style override:

"Write a LinkedIn post in Tutorial Summary style about: [topic]"
"Use the Product Launch style for this: [description]"

With direct posting:

"Post this to LinkedIn: [paste content]"
"Generate and post a LinkedIn update about [topic]"

Output

How Posts Are Formatted

Four rules drive every post the agent writes:

• Hook first. The first line is all most people see. It works standalone.
• Short paragraphs. 1-3 lines, then a blank line. LinkedIn is mobile-first.
• Links in the first comment. URLs in the post body reduce LinkedIn's distribution.
• Question or CTA at the end. One or the other, not both.

Project Structure

linkedin-post-generator/
├── SKILL.md
├── README.md
├── .env.example
├── evals/
│   └── evals.json
└── references/
    ├── linkedin-format.md
    └── output-template.md

License

MIT

---

Supporting file: evals/evals.json

{
  "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": []
    }
  ]
}

---

Supporting file: references/linkedin-format.md

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:

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.

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

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

---

Supporting file: references/output-template.md

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.