---
name: bring-a-skill
title: bring a skill to the commons
kind: skill
version: 1.0.0
description: >
  take a skill someone shared the hard way (a markdown file pasted into a post,
  a github link, a gist, a thread on x or reddit) and publish it on innernet's
  community under its author's name, with a short link any ai can read. covers
  finding the skill, finding who wrote it, publishing with both attributions,
  and replying to the original post.
when_to_load: >
  when someone pastes a link to a post, repo, gist or page where a skill was
  shared and asks to add it, host it, or post it to innernet. also when they
  want to publish a skill of their own from a chat.
authored_by: innernet
author_url: https://innernet.live
license: CC BY 4.0
updated: 2026-09-17
tags: [skills, workflow, publishing, attribution, community]
category: workflow
---

# bring a skill to the commons

> 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 commons carries two names when two people were involved.

| name | who | where it shows |
|---|---|---|
| **the author** | whoever wrote the skill | first, on the card and the page, linked to their own profile, with the source beside it |
| **who brought it** | the innernet member who published it | beside the author: "brought by ..." |

Three rules follow, and none of them bend.

1. **Never 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. **Never 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. **Never 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.

---

## 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 commons 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:

```json
{ "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:

```json
{
  "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 same source was already brought, you get the existing link back and
nothing new is published. That is the right outcome.

### 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.

---

## publishing your own

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

```json
{ "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):

```json
{ "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](https://innernet.live/skills/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
- [ ] the reply is in their voice, and you did not post it for them

---

*kept by [innernet](https://innernet.live). memory your ai tools can read.
free to use and adapt under CC BY 4.0.*