# Skill Creator (for MS Copilot)

A skill for creating new skills that work within the MS Copilot setup.

## What this is

MS Copilot does not yet natively support a skills framework. As a workaround, we
store skills as `<skill_name>.md` files (written in Markdown) inside a SharePoint
folder. Each user should have their own 'skill_library' folder in their own OneDrive and also each Team can have their common 'skill library' folder in their teams's sharepoint.
Users reference a skill by attaching it with the **PLUS (+) button** in the MS Copilot chat.

Because of this setup, a few things differ from a "normal" skill:

- There is **no YAML frontmatter and no auto-loaded description** — Copilot can't
  dynamically read skill descriptions. Instead the skill just has a short but speaking name.
- There are **no bundled files, scripts, or executable resources** — everything the
  skill needs must live inside the single `.md` file as instructions.

Your job when this skill is referenced is to help the user go from an idea to a
finished `<skill_name>.md` file they can drop into the skills folder.

## The process

At a high level:

1. Understand what the user wants the skill to do.
2. Decide whether you have enough information. If not, either ask the user or do
   web research to fill the gaps.
3. Write the skill as a Markdown document.
4. Create it as a `.md` file using Python code execution.
5. Tell the user where to put the file so Copilot can use it.

Figure out where the user is in this process and jump in to help them move forward.
Be flexible — if they already have a clear idea, go straight to writing.

## Step 1: Understand the intent

Start by understanding what the user actually wants. Often the conversation already
contains a workflow they want to capture (e.g. "turn this into a skill"). If so,
pull the answers from the conversation first — the steps taken, the tools used, the
input and output formats, any corrections the user made along the way.

Try to pin down:

1. **What should this skill enable Copilot to do?**
2. **When should it be used?** (what kinds of requests or situations)
3. **What's the expected output?** (a document, a summary, a rewrite, a checklist…)
4. **Are there edge cases or special rules** the skill needs to handle?

## Step 2: Reason about whether you have enough information

This is the key judgement step. Before writing, honestly assess whether you understand
the task well enough to write a skill that will work across many different future
requests — not just the one example in front of you.

If something important is missing or ambiguous, choose the cheapest good option:

- **Ask the user** when the gap is about *their* preferences, context, or intent —
  things only they can answer (e.g. "what tone should the output have?", "which
  internal system does this refer to?", "what counts as success here?"). Keep
  questions focused; ask only what you genuinely need.
- **Do web research** when the gap is about *general or factual* knowledge you can
  look up (e.g. a standard format, a best-practice workflow, how a public tool or
  API works, terminology in a domain). Come back with that context so the user
  doesn't have to explain it.

Don't guess on things that matter. But also don't interrogate the user about things
you can reasonably figure out or research yourself. When in doubt about whether you
have enough, briefly state your understanding back to the user and confirm before
writing.

## Step 3: Write the skill

Write the skill as a clean Markdown document. Structure it roughly like this:

```markdown
# [Speaking Name of the Skill]

[One or two sentences saying what this skill does and when to use it — this
replaces the missing frontmatter description, so make it clear and human-readable.]

## [Section headings as needed]

[Instructions, written in the imperative.]
```

Writing guidelines that make skills work well:

- **Explain the *why*, not just the *what*.** Copilot is smart and follows reasoning
  better than rigid rules. Instead of stacking ALL-CAPS MUSTs, explain why something
  matters so it can apply judgement in cases you didn't foresee. If you catch yourself
  writing lots of NEVER/ALWAYS, that's a yellow flag — reframe and explain instead.
- **Keep it general, not overfit.** The skill will be used many times across many
  different prompts. Avoid baking in the specifics of one example; aim for instructions
  that generalize.
- **Define output formats explicitly when they matter.** If the output should follow
  a fixed structure, show the template:
sample output structure for a report:
```markdown
  # [Title]
  ## Summary
  ## Key findings
  ## Recommendations
```

- **Use examples where they help.** A short Input → Output example often communicates
  more than a paragraph of description.
- **Keep it focused.** Everything the skill needs must live in this one file, so include
  what's necessary — but cut anything that isn't pulling its weight.
- **No malicious or misleading skills.** A skill's contents shouldn't surprise the user
  relative to its stated purpose. Roleplay or persona skills are fine.

Write a draft, then reread it with fresh eyes and improve it before finalizing.

## Step 4: Create the .md file

Once the content is ready, create the file using Python code execution. Save it as
`<skill_name>.md` using a short, lowercase, underscore separated name that
matches the skill (e.g. `meeting_notes.md`, `competitor_research.md`).

```python
skill_content = """[the full markdown skill text goes here]"""

with open("skill_name.md", "w", encoding="utf-8") as f:
    f.write(skill_content)
```

Use the actual chosen filename in place of `skill_name.md`.

## Step 5: Tell the user how to install it

After creating the file, give the user clear next steps:

1. Download the generated `<skill_name>.md` file.
2. Copy it into your own **skills_library** folder in your OneDrive.
3. In a new MS Copilot chat, reference the skill using the **PLUS (+) button** to
   attach the `.md` file, then test out the newly created skill.

## Iterating

Skills get better with use. If the user comes back and says the skill isn't behaving
the way they want, treat their feedback as a signal about the general case, not just
the one example:

- Don't bolt on a narrow fix for a single prompt — look for the underlying pattern
  and adjust the instructions so they generalize.
- If something is being ignored or misapplied, try reframing it and explaining the
  reasoning rather than making the rule louder.
- Remove instructions that aren't helping; a leaner skill is usually a better one.

Then regenerate the `.md` file and have the user re-test.