agentleFS
chaoz23chaoz23/agent-native-launch-kit/SKILL.md

launch-kit

Skill1 starsChanged 4 months agoApache-2.0View on GitHub

Plan and execute community promotion for an open-source repo or an outbound PR, with a first-class focus on agent discoverability (MCP registries, framework example PRs, packaging for uvx/npx/brew, GEO'd READMEs) alongside human channels (Show HN, Reddit, X, dev.to). Produces a readiness scorecard, positioning, a channel plan, and ready-to-post draft assets. Use when the user says "promote", "launch", "get adoption/contributors/stars", "spread the word", "market my repo/tool/PR", or wants awareness for a GitHub project. Drafts only — never auto-posts to HN/Reddit/X.

5 other projects use a version of this.

Adopted by

Most recently taken up by

  • Other versions5 projects use a version of this.

    Word for word · 0

    None found.

    Edited · 0

    None found.

    Wrote their own version · 5

    1. miraya-dev/launch-kit★ 1same name
    2. alvaldes/launch-skills★ 0same name
    3. Barbhuiya12/launch-kit★ 0same name
    4. omnigami-ai/pro-skills★ 0same name
    5. thanatchon36/skills★ 0same name

    How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.

The file

We split this skill into the rules it gives an agent

5 rules. 0 are common, 4 are distinctive, and 1 is very specific to this project.

  • 0

    Common

    Most of the 4 edited versions we read keep these.

  • 4

    Distinctive

    This author's own choices. Worth a look.

  • 1

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Before first use, fill these in (or keep them in your agent's memory):

    line 25
  2. Distinctive:

    Before promoting, confirm the repo is worth landing traffic on.

    line 51
  3. Distinctive:

    Run the test suite: Only promote green repos; a launch landing on a broken quickstart is worse than no launch.

    line 69
  4. Distinctive:

    Spec-first / framework projects score differently: When the product is a spec or protocol, reinterpret:

    line 74
  5. Very specific:

    Add/refresh tool.json; add llms.txt.

    line 158

“Common” is measured: kept by at least 6 in 10 of the 4 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Launch Kit — agent-native OSS launch playbook

Promote open-source tools so they get awareness, real-world adoption, and contributors (human, agent, or other). The premise: for tools shaped for machine consumption (tool.json, --pipe, --schema, deterministic exit codes, MCP servers), most reach comes not from humans browsing GitHub but from appearing in the surfaces agents and agent-builders read from. Treat classic SEO as GEO/AEO — generative/agent engine optimization.

Configuration

Before first use, fill these in (or keep them in your agent's memory):

  • OWNER — the GitHub handle launches run from.
  • LOCAL_MODEL_CMD — optional command for cheap first drafts (e.g. ollama run gemma3:12b); if absent, the orchestrating model drafts directly.
  • TRACKER — where follow-ups live (issues, a reminders file, a calendar).

Golden rules

  • Draft, never auto-post. HN, Reddit, and X ban automated submissions; a bot post torches the account and the launch. Generate polished drafts; the human posts them from their own accounts, in their own voice.
  • Packaging beats posting. A tool an agent can run via uvx/npx/brew with one line gets adopted; a clone-only repo does not. Fix packaging before promoting.
  • Local models draft, the orchestrator synthesizes. First drafts of copy on a cheap local model; edit and finalize with judgment.
  • One tool, end to end, as a template. Launch one tool fully first; reuse the assets as templates for the rest of a portfolio.
  • Be honest about the split. Separate what an agent can do autonomously (topics, README edits, awesome-list and example PRs, all drafts) from what only the human can do (posting to personal accounts; anything gated on ToS or authenticity).

Phase 1 — Readiness audit (score 0–100)

Before promoting, confirm the repo is worth landing traffic on. Each gap is a blocker to fix first, not a reason to skip promotion.

DimensionCheckWeight
PackagingInstallable via uvx/pipx/npx/brew, not clone-only25
Agent surfacetool.json at root, --pipe, --schema, exit codes, MCP if applicable20
README/GEOProblem-first headings, example queries phrased as users ask, "vs alternatives", copy-paste quickstart20
ProofDemo GIF / asciinema / example output in README10
MetadataRich description + GitHub topics set10
License + CONTRIBUTINGPresent, permissive, contributor on-ramp10
SignalExisting stars/issues/PRs, upstream footprint5

During the audit:

  • Check package-name availability immediately (pip index versions <name>, npm view <name>). A free name upgrades packaging from "gap" to "quick win" and changes the whole sequencing.
  • Run the test suite. Only promote green repos; a launch landing on a broken quickstart is worse than no launch.
  • Check convention consistency across the portfolio — reviewers and agents hit multiple repos; drift looks like abandonment.

Spec-first / framework projects score differently. When the product is a spec or protocol, reinterpret:

  • Agent surface = can an agent implement conformance from the spec alone, without reading implementation source? A one-method interface IS the agent surface; tool.json may not apply.
  • Proof = a committed sample output excerpted in the README, plus CI enforcing the spec's central invariant.
  • Packaging still applies via the reference implementation: ship a zero-arg bundled demo so uvx <name> demonstrates the whole value prop with no arguments, API keys, or config. Bundle the demo fixture inside the package and add a drift-guard test (bundled copy byte-identical to the source copy).
  • Set GitHub topics at repo creation, not launch time.

Report the score, the top 3 blocking gaps, and fix the cheap ones (topics, tool.json, llms.txt, README sections) directly. Then name the critical-path unlock — the single action every other channel depends on (usually packaging: registries want an installable package; every asset quotes the uvx/npx one-liner). Sequence the whole plan behind it.

Phase 2 — Positioning

Produce, in ≤120 words:

  • One-liner — the description a model would repeat when recommending it.
  • Job to be done — the exact problem, phrased how a sufferer phrases it.
  • Wedge — why this vs. the obvious alternative.
  • Audiences — human personas AND target agent frameworks/clients.

For spec/framework projects, also name the launch argument: a public design debate (an ADR with all positions recorded, including the losing ones, and the evidence that would reopen it) is a first-class launch asset — "come argue with our reasoning" converts better than "come use our tool" when the product is a spec. Invite the attack explicitly in the HN/Reddit drafts.

Phase 3 — Channel map

Two tracks; route by domain. See assets/channel-map.md for surface rules.

  • Track A — Agent discoverability (highest leverage): packaging (PyPI/npm/Homebrew one-liner); MCP registries for MCP-speaking tools; upstream example PRs into framework examples/ (pydantic-ai, LangChain, LlamaIndex, smolagents, CrewAI); GEO'd README; awesome-lists; GitHub topics; llms.txt.
    • If the tool is an MCP server, follow assets/mcp-server-launch-playbook.md end-to-end. It fixes the dependency order (glama.json + Dockerfile + server.json + ownership marker BEFORE any publish; Glama BEFORE the awesome-mcp PR), collapses the human surface to one batched "log in + run a couple commands" handoff, and lists the exact gotchas (macOS twine keyring hang, server.json launching the CLI not the server, the forced-marker point release, the ≤100-char registry description) that otherwise arrive as "you missed a step" bot emails.
  • Track B — Human distribution: Show HN, one domain subreddit, X thread, dev.to. The meta-story ("I build agent-native tools") often out-performs any single tool.

Phase 4 — Asset generation

For each chosen channel, draft the artifact (templates in assets/asset-templates.md):

  1. First-draft on a local model if configured. Hard-won lessons:
    • Give an explicit character budget for titles (HN ≈ 80 chars) or the model reuses the one-liner verbatim as the title.
    • Split GUARANTEES from LIMITATIONS in the context — otherwise deliberate design constraints get misfiled as weaknesses instead of sold as features.
    • X drafts need "no hashtags, no emoji, first person singular" in the prompt, or small models produce recognizable AI-slop threads.
    • Body prose is ~80% usable; titles and positioning nuance always need a synthesis pass.
    • Local cold-start can take 60–90s — run batches in the background.
  2. Edit for voice, accuracy, and channel rules (title length, self-promo norms).
  3. Save everything as one launch packet per repo — scorecard, positioning, channels, all drafts, execution-split table, tracking plan. One file the human can read top-to-bottom and act on. Example: examples/agent-compat-launch-packet.md.

Minimum set: Show HN post, one Reddit post, an X thread, an MCP registry submission (if MCP), one upstream example PR plan.

Phase 5 — Discoverability hardening (agent-executable)

  • gh repo edit <repo> --add-topic <t1> --add-topic <t2> ...
  • Add/refresh tool.json; add llms.txt; add "For agents" and "vs alternatives" README sections; add a demo GIF or instructions for one.
  • Tune the GitHub description to be trigger-phrase rich.

Phase 6 — Execution split

Emit a table: Action | Who | Status. Agent-autonomous: topics, README and tool.json edits, awesome-list PRs and upstream example PRs from the owner's account, all drafts, nudging the owner's own stalled PRs (with their ok). Human-only: HN/Reddit/X posts, registry tokens, replying as themselves in maintainer threads.

Phase 7 — Track & follow up

  • Schedule a follow-up in TRACKER (3 days post-launch is a good default).
  • Watch signals: gh repo view <repo> --json stargazerCount, package download stats, gh pr view <n> --json comments,reviews for outbound PRs.
  • Standing items each run: nudge stalled outbound PRs, un-draft finished PRs, port any new lesson back into this playbook.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.