Attribution for a free Claude Code skill goes in two places: the SKILL.md frontmatter and a credits or attribution section near the top of the skill body. At minimum, include your name, a contact or GitHub handle, a license identifier (MIT is the standard default), and a version number. If you built on an existing community skill, include the original author's name and a link to the source.
This guide reflects the attribution standard AEM uses when engineering skills for production distribution.
TL;DR: Add an author, version, and license field to your SKILL.md frontmatter. Add a credits section in the body for longer attribution or to acknowledge borrowed work. Publish the SKILL.md itself as the attribution record — it travels with the skill wherever it gets copied. Use MIT license unless you have a specific reason to restrict reuse.
What Frontmatter Fields Carry Attribution?
The SKILL.md frontmatter carries the attribution fields that will survive copying and redistribution. Six fields matter: name, description, author, version, license, and source. Fill all six before distributing. Without them, the skill has no legal status for reuse. On GitHub, 46% of public repositories carry no license (GitHub, 2024), which means no explicit right to modify or redistribute.
The fields to include:
---
name: your-skill-name
description: "What this skill does and when to use it — single line, under 1,024 characters"
author: "Your Name (@github-handle)"
version: "1.0.0"
license: "MIT"
source: "https://github.com/yourusername/your-repo"
---
None of these fields are required by Claude Code to run the skill (Claude Code specification). The description field is the only one that affects skill behavior. The rest are for humans: people who install your skill, fork it, or need to report an issue.
The author field is the most important attribution element. Without it, your skill circulates anonymously. With 700,000+ community skills on platforms like SkillsMP (SkillsMP, 2026), anonymous attribution means no credit and no feedback path when the skill breaks.
"Developers don't adopt AI tools because they're impressive — they adopt them because they reduce friction on tasks they repeat every day." — Marc Bara, AI product consultant (2024)
That applies to attribution too. Clear authorship reduces friction for the next developer who wants to ask a question or report an edge case. Your contact information is a feature.
Where Does Attribution Go Inside the Skill Body?
The frontmatter covers the metadata. The skill body is for anything requiring more than a single-line value. Use a credits section for multi-contributor acknowledgements, third-party attributions, and licensing context that does not fit in a single YAML field. Keep it brief: three to five lines of prose is the right size.
A credits section in the body handles three cases:
- Skills built on or adapted from someone else's work
- Skills with multiple contributors
- Skills that incorporate licensed content or research
Place the credits section immediately after the frontmatter, before the description of what the skill does:
## Credits
Original skill by Jane Smith (@janesmith). This version adapts the output contract
pattern from her article: https://example.com/article
Additional contributions: Alex Chen (@alexc), 2025.
Keep it short. The credits section is not a changelog — version history belongs in a separate CHANGELOG.md file if needed (which should not live in the skill folder itself, since that adds noise Claude Code has to ignore). See Why Shouldn't I Include README.md or CHANGELOG.md in My Skill Folder for why that matters.
What License Should I Use for a Free Skill?
MIT is the correct default for free Claude Code skill distribution. It grants permission to use, copy, modify, and distribute your skill, including commercially, with one condition: the copyright notice stays intact. MIT is the most widely adopted permissive license, appearing in approximately 30% of all licensed open-source projects (OSI, 2025).
MIT allows anyone to use, copy, modify, and distribute your skill, including commercially, as long as they retain the original copyright notice. For a SKILL.md file, that means keeping the author field and license line intact. The full MIT license text is 170 words and is too long to embed in SKILL.md itself. Reference it instead:
license: "MIT — https://opensource.org/licenses/MIT"
Apache 2.0 is the right choice when you want patent protection included, which matters if your skill incorporates patentable logic or integrates with proprietary APIs. Unlike MIT, Apache 2.0 includes an explicit patent grant. In the npm ecosystem, 53% of packages use MIT; Apache 2.0 is the dominant choice only in Java, where it accounts for 69% of Maven components (OSI, 2025).
Creative Commons licenses apply to creative works, not software. A SKILL.md file is software. Using CC licenses on skills creates licensing confusion and is not the community norm. Poorly licensed open source is a documented problem: 33% of commercial codebases audited in 2025 contained components with no license or custom terms (Black Duck OSSRA, 2025).
In our commissions at AEM, we've reviewed over 200 community skills for clients integrating them into production workflows. Fewer than 15% included any license field in the frontmatter (AEM commission data, 2026). That is not a legal emergency for free personal use, but it matters for team adoption and redistribution: without a license, others have no explicit right to use your skill commercially or modify it.
How Do I Credit a Skill I've Built On Someone Else's Work?
If your skill substantially adapts an existing community skill, include the original author in both the frontmatter and the credits section. Name the original skill, what you changed, and a link to the source. This is not optional courtesy: under MIT, retaining the copyright notice and attribution is the one condition that keeps redistribution rights intact.
In frontmatter:
author: "Your Name (@yourhandle)"
based_on: "Original work by Jane Smith (@janesmith) — https://github.com/janesmith/original-skill"
license: "MIT"
In the credits section of the body, name the original skill, what you changed, and why. The distinction between "forked" and "inspired by" matters: a fork uses substantial portions of the original logic; inspired-by means you wrote from scratch after reading their approach.
Nobody files a cease and desist over a SKILL.md. But attribution is how a community knows who to ask when the skill breaks, and it's how skill authors get the recognition that motivates building more. License conflicts compound quietly: 56% of audited commercial codebases contain at least one license conflict between components (Black Duck OSSRA, 2025). Correct attribution from the start prevents that inheritance problem downstream.
The one case where attribution becomes a legal issue: skills that incorporate copyrighted text — documentation, proprietary API specifications, or licensed datasets — as reference file content. If a reference file contains text you don't own, your license cannot grant others the right to redistribute it. Strip proprietary content from reference files before publishing, or confirm the source material's license permits redistribution.
What Does Attribution Look Like on GitHub vs. Platform Submissions?
Attribution on GitHub and attribution on SkillsMP or SkillHub differ in scope. GitHub reads attribution from a README.md at the repo root and any license file you include. Platform submissions pull directly from SKILL.md frontmatter fields. Get the frontmatter right first, and both channels are covered with no duplication of effort.
GitHub repository: The attribution lives in three places — the SKILL.md frontmatter, a README.md at the repository root (not inside the skill folder), and any GitHub topics or description metadata you add. The README.md at repo level is the primary attribution record for GitHub browsers.
Platform submissions: SkillsMP and SkillHub pull attribution from the SKILL.md frontmatter fields. Fill in author, version, and license correctly before submission. ClaudeMarketplaces picks these up automatically when it indexes the skill from GitHub or SkillsMP.
For how to structure a skill for GitHub publication specifically, see Can I Publish My Skill on GitHub. For the full packaging process before distribution, see How Do I Package a Skill for Distribution to Others.
Frequently Asked Questions
The complete attribution record for a free Claude Code skill is four SKILL.md frontmatter fields: author, version, license (MIT), and source. Adding those fields takes under two minutes, satisfies redistribution requirements across GitHub and major skill platforms, and keeps your authorship intact wherever the skill gets copied.
Do I have to add a license to a free skill I'm sharing? Technically no. Practically yes. Without a license, users have no explicit right to modify or redistribute your skill. MIT takes 30 seconds to add and removes all ambiguity. Add it.
What happens if I distribute a skill with no attribution and someone forks it?
The fork circulates without connection to you. No credit, no feedback, no way for users to find updates. Adding just the author field takes 10 seconds and keeps the connection intact wherever the skill gets copied.
Can I use a Creative Commons license for my Claude Code skill? Not correctly. Creative Commons licenses apply to creative works, not software. SKILL.md files are software. Use MIT or Apache 2.0. Using CC on a skill creates licensing ambiguity without the protections you'd actually want.
What should I put in the author field — my real name or a GitHub handle?
Use the format that makes you findable: "First Last (@github-handle)". Both elements matter. The real name adds credibility on platforms. The GitHub handle gives people a contact path without requiring an email address.
If I add attribution to a skill I adapted from someone else, do I need their permission? Only if their license requires it. MIT and Apache 2.0 do not require permission for adaptation — just attribution. If the original had no license, the safest path is to reach out and ask, or to write the skill fresh rather than adapting the existing one.
Should the credits section go before or after the skill instructions? Before. Put it immediately after the frontmatter, before any description of what the skill does. That way it's visible without scrolling, and it doesn't interrupt the instructions that Claude Code actually reads during execution.
Last updated: 2026-04-26