bring a skill to the community

people share skills the hard way: a wall of markdown in a reply, a github link with no explanation, a screenshot of a prompt. the skill is good and almost nobody can use it. this is how to give it one short link that any ai can read, with the author's name on it.

You need the innernet connection (the innernet_publish_skill tool, or POST https://innernet.live/api/v1/skills with a key). Everything below is one tool call once you know three things: what the skill says, who wrote it, and where it came from.

the law: a skill is its author's

Every skill on the community carries two names when two people were involved.

Three rules follow, and none of them bend.

1. 1Never publish someone else's skill as the person's own. mine: true is only for a skill the person you are working with wrote.
2. 2Never name an author without a source. Publishing under someone's name requires source_url: the post, repo or page it came from. It is printed next to their name so anyone can check it is really theirs.
3. 3Never rewrite someone else's skill. Pass their markdown verbatim. innernet writes its own manifest on top (name, description, author, source) and leaves the body alone. If the skill needs fixing, that is the author's call.

innernet holds the rest of the line itself:

• an author, once recorded, never changes. Not by a later publish, not by

bringing the same skill again under another name. The database refuses it.

• one skill, one page. A skill is recognised by its words, not its title or

its link. If the same skill is already on the community, or innernet already keeps it, you get already and its existing link, with the author it is credited to. Nothing new is published, and renaming it does not get around that. Give the person that link: it is the right answer.

• the author is told. See the author's letter.

the steps

1. read the link

Open what the person pasted. You are looking for the skill itself, which shows up in one of four shapes:

• a file or folder on github, or a gist. The skill is the SKILL.md (or the

one markdown file). innernet can fetch these itself.

• a post that links to a repo. Follow the link. The skill lives in the repo;

the post is where it was found.

• markdown pasted into the post or a reply. Copy it exactly, from the first

line of the manifest (---) or the first heading to the end.

• a screenshot or a thread of fragments. Transcribe it faithfully and tell

the person you did, so they can check it before it goes out under someone's name.

If what you find is not a skill (it is a product announcement, a prompt with no method, a link to a paid course), say so and stop. The community is a shelf of things an ai can act on.

2. find the author

The author is whoever wrote the skill, which is not always whoever posted about it.

• A repo names its owner in the url. A skill's own manifest may name its author

(authored_by or author). When the manifest names someone, believe it over the url.

• A post by one person about another person's repo: the repo owner is the

author. The post is only where it was found.

• Use the name as they write it themselves: @handle on x, u/name on

reddit, the github login for a repo, a real name only if that is what their profile leads with.

• author_url is their own profile on the platform the skill was found on.

If you cannot tell who wrote it, ask the person. Do not guess, and do not fall back to the poster.

3. check it may be shared

Look for a licence (a repo's LICENSE, a line in the manifest, a note in the post). Open licences (MIT, Apache, CC BY and the like) are fine. If the author says not to redistribute it, or it is clearly paid or private material, do not publish it. Tell the person, and offer to share the link to the original instead.

Someone posting a skill publicly for others to use is the normal case, and bringing it here with their name and a link back is what attribution is for.

4. publish

Start with the link alone. innernet reads github, gists, x and reddit on its own, finds the author, and follows one link from a post to the repo behind it:

{ "source_url": "https://x.com/someone/status/1234567890" }

When it cannot read the link (a login wall, a platform it does not know, a skill that was pasted rather than linked) it says exactly what is missing. Call again with what you read yourself:

{
  "source_url": "https://www.reddit.com/r/ClaudeAI/comments/abc123/my_review_skill/",
  "content": "---\nname: code-review\n...the skill, verbatim...",
  "authored_by": "u/someone",
  "author_url": "https://www.reddit.com/user/someone",
  "description": "review a pull request the way a careful senior engineer would: ...",
  "tags": ["code", "review"]
}

Write the description for a model deciding whether to load the skill: what it makes an ai able to do, in one or two sentences. Use the skill's own description when it has a good one.

If the skill is already on the community, or innernet already keeps it from that same source, you get the existing link back and nothing new is published. That is the right outcome: hand that link over.

Several at once: see a whole list at once below. Send them in one call rather than one call each, so the person gets one answer and one reply per author.

5. hand back the link, and the reply

The result carries:

• url: the short link, innernet.live/skills/<slug>. Pasting it into any ai

is the whole instruction. url + /raw is the plain markdown.

• attribution: who it is credited to and who brought it, as recorded. Read it

back to the person.

• reply_draft: a starting point for answering the original post.

Rewrite the reply in the person's own voice. A good one is short, says what the link does, and makes it obvious the author is credited:

put your review skill somewhere easier to pass around: innernet.live/skills/someone-code-review. paste that link into any ai and it just works. it's under your name and links back to this post.

Never post the reply for them unless they ask you to. And never reply to the same author twice about the same skill.

the author's letter

Every skill brought in under someone else's name queues one short letter to its author. At 19:00 IST each day, every author with something new gets one letter listing all of it: where each skill lives, that it is credited to them and unchanged, who brought it, and that they can have any of it taken down with one reply or one link, no reason needed.

The letter only ever goes to an address the author published themselves:

• one you pass as author_email, because you read it on their page, repo or

site (never guess one, and never pass the person's own);

• the skill's own manifest, if it names one;
• their public GitHub profile, for skills found on GitHub.

With none of those, nobody is written to. The result's author_notice says which happened. Tell the person:

• queued: the author hears tonight, at the masked address shown;
• no_contact: there is no address, so **their reply on the original post is

the author's notice**, and the reply draft matters more;

• suppressed: the author has asked innernet not to email them.

If an author asks for a skill to come down, a person at innernet takes it off the community. You do not need to do anything.

a whole list at once

Everything above works on a list. Someone finding skills usually finds five in an afternoon, from five different people.

{ "source_urls": [
  "https://x.com/someone/status/1234567890",
  "https://github.com/maker/agent-skills/tree/main/skills/code-review",
  "https://gist.github.com/another/abc123"
] }

For anything more than links, send items instead. They can have different authors, and they can mix other people's skills with the person's own:

{ "skills": [
  { "source_url": "https://github.com/maker/repo/blob/main/SKILL.md" },
  { "source_url": "https://www.reddit.com/r/ClaudeAI/comments/abc/x/",
    "content": "---\nname: review\n...",
    "authored_by": "u/someone",
    "author_url": "https://www.reddit.com/user/someone" },
  { "content": "---\nname: our-brief\n...", "mine": true }
] }

Up to 20 a call, and 25 a day per person.

how a batch behaves

Every item is its own attempt. Nothing is all-or-nothing.

• each result says published, already (the community already has it, from the

same source, and here is its link), failed (with an error naming what to pass) or skipped (the day's allowance ran out);

• an unreadable link never costs the others;
• the same link twice in one call publishes once;
• results comes back in the order you sent, with counts, urls and a

summary.

Work the failures the same way you would work one: read the page yourself, then call again with just those items, adding content, authored_by and author_url.

one reply per author

The result carries reply_drafts, grouped by author. Two skills by the same maker get one draft naming both. Rewrite each in the person's own voice, and reply to each author once, not once per skill.

take several back

{ "withdraw": ["maker-code-review", "another-planning"] }

their own pages, in bulk

{ "project_slug": "my-project", "pages": ["code-review", "weekly-report"] }

publishing your own

A skill the person wrote, in this chat or pasted in:

{ "content": "...the skill...", "mine": true }

A skill that already lives as a page in their innernet (the better home for something they will keep editing, because the link always shows the page as it is now, never a copy):

{ "project_slug": "my-project", "page": "code-review" }

If a page is not a skill yet, give it a manifest first. The format is one markdown file with kind: skill and a description on top: the skill format.

To take anything back: { "withdraw": "<slug or url>" }.

if the author turns up

That is the point. They can:

• keep it as it is. It is already under their name.
• ask for a change or a removal at connect@innernet.live. Every brought

skill's page says so.

• take it over. With an innernet of their own they can keep the skill as a

page in their memory and publish that, and it then updates whenever they edit it.

When you reply to an author, say this plainly. People are generous about their work being carried somewhere useful when their name is on it and the way out is obvious.

before you publish, check

• it is actually a skill: instructions an ai can act on, not an ad
• the body is the author's words, verbatim
• the author is who wrote it, named the way they name themselves
• source_url points at where it really came from
• nothing in the licence or the post says "do not share"
• mine: true only if the person you are working with wrote it
• the person saw the title, the author and the link before it went out, whenever there was any doubt about whose it is
• anything that came back already was handed over as its existing link, under the name it already carries
• you told the person whether the author will get a letter tonight, or whether their reply is the only notice the author gets
• the reply is in their voice, and you did not post it for them
• in a batch: you read every error, and told the person plainly what landed and what still needs them
• in a batch: one reply per author, not one per skill

kept by innernet. memory your ai tools can read. free to use and adapt under CC BY 4.0.