Microsoft Skill Creator

Microsoft LearnOfficialPublished by Microsoft Learn

Skill
Workflow
Agent tooling
CC-BY-4.0
Low risk

From the author

Create agent skills for Microsoft technologies using official documentation. Use whenever the user wants to build, generate, or scaffold a skill for any Microsoft technology (Azure, .NET, M365, VS Code, Bicep, etc.)—even phrased casually like "make a skill for Cosmos DB." Investigates the topic via official docs, then generates a hybrid skill with essential knowledge stored locally and dynamic lookups for depth.

— the description by Microsoft Learn

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The Microsoft Skill Creator is a meta-skill designed to scaffold and build specialized agent skills for the Microsoft ecosystem, including Azure, .NET, M365, and VS Code. It guides the user through an investigation process using official Microsoft Learn documentation and code samples, then generates a hybrid skill structure. This structure combines essential local knowledge for stability with dynamic search capabilities for deep-dive information, ensuring agents remain informed on specific Microsoft technologies.

What it does

Scaffolds new agent skills using predefined templates for SDKs, Azure services, and frameworks.
Automates the investigation of Microsoft technologies via Learn MCP tools or CLI fallbacks.
Generates structured SKILL.md files with frontmatter and core knowledge.
Provides patterns for balancing local documentation with dynamic search queries.
Includes templates for common Microsoft technology types like libraries and cloud services.
Integrates search and fetch capabilities to keep agent knowledge current.

When to use it

When you need to create a new agent skill for a specific Microsoft technology.
When you want to standardize the structure of your agent's knowledge base.
When you need to combine static documentation with dynamic lookup capabilities.
When building agents that require deep integration with Azure or .NET ecosystems.

Advantages

Ensures consistency across agent skills using standardized templates.
Reduces manual effort in gathering and structuring technical documentation.
Provides a clear path for agents to access both local and remote technical data.
Supports both MCP-enabled environments and CLI-based workflows.

Usage examples

“Create a skill for Cosmos DB.”: The agent initiates the investigation process, searches for Cosmos DB overview and architecture, and generates a structured skill package including local setup guides and dynamic search links.
“Make a skill for Semantic Kernel.”: The agent uses the provided templates to create a Semantic Kernel skill, populating it with core concepts, quick-start code, and search queries for plugins and planners.

Install

Download the skill as a ZIP:
https://autogineer.com/agent-skills/microsoftdocs/microsoft-skill-creator/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip microsoft-skill-creator.zip -d .agents/skills

Documentation by Microsoft Learn

Microsoft Skill Creator

Create hybrid skills for Microsoft technologies that store essential knowledge locally while enabling dynamic Learn MCP lookups for deeper details.

About Skills

Skills are modular packages that extend agent capabilities with specialized knowledge and workflows. A skill transforms a general-purpose agent into a specialized one for a specific domain.

Skill Structure

skill-name/
├── SKILL.md (required)     # Frontmatter (name, description) + instructions
├── references/             # Documentation loaded into context as needed
├── sample_codes/           # Working code examples
└── assets/                 # Files used in output (templates, etc.)

Key Principles

Frontmatter is critical: name and description determine when the skill triggers—be clear and comprehensive
Concise is key: Only include what agents don't already know; context window is shared
No duplication: Information lives in SKILL.md OR reference files, not both

Learn MCP Tools

Tool	Purpose	When to Use
`microsoft_docs_search`	Search official docs	First pass discovery, finding topics
`microsoft_docs_fetch`	Get full page content	Deep dive into important pages
`microsoft_code_sample_search`	Find code examples	Get implementation patterns

CLI Alternative

If the Learn MCP server is not available, use the mslearn CLI from the command line instead:

# Run directly (no install needed)
npx @microsoft/learn-cli search "semantic kernel overview"

# Or install globally, then run
npm install -g @microsoft/learn-cli
mslearn search "semantic kernel overview"

MCP Tool	CLI Command
`microsoft_docs_search(query: "...")`	`mslearn search "..."`
`microsoft_code_sample_search(query: "...", language: "...")`	`mslearn code-search "..." --language ...`
`microsoft_docs_fetch(url: "...")`	`mslearn fetch "..."`

Generated skills should include this same CLI fallback table so agents can use either path.

Creation Process

Step 1: Investigate the Topic

Build deep understanding using Learn MCP tools in three phases:

Phase 1 - Scope Discovery:

microsoft_docs_search(query="{technology} overview what is")
microsoft_docs_search(query="{technology} concepts architecture")
microsoft_docs_search(query="{technology} getting started tutorial")

Phase 2 - Core Content:

microsoft_docs_fetch(url="...")  # Fetch pages from Phase 1
microsoft_code_sample_search(query="{technology}", language="{lang}")

Phase 3 - Depth:

microsoft_docs_search(query="{technology} best practices")
microsoft_docs_search(query="{technology} troubleshooting errors")

Investigation Checklist

After investigating, verify:

[ ] Can explain what the technology does in one paragraph
[ ] Identified 3-5 key concepts
[ ] Have working code for basic usage
[ ] Know the most common API patterns
[ ] Have search queries for deeper topics

Step 2: Clarify with User

Present findings and ask:

"I found these key areas: [list]. Which are most important?"
"What tasks will agents primarily perform with this skill?"
"Which programming language should code samples prioritize?"

Step 3: Generate the Skill

Use the appropriate template from skill-templates.md:

Technology Type	Template
Client library, NuGet/npm package	SDK/Library
Azure resource	Azure Service
App development framework	Framework/Platform
REST API, protocol	API/Protocol

Generated Skill Structure

{skill-name}/
├── SKILL.md                    # Core knowledge + Learn MCP guidance
├── references/                 # Detailed local documentation (if needed)
└── sample_codes/               # Working code examples
    ├── getting-started/
    └── common-patterns/

Step 4: Balance Local vs Dynamic Content

Store locally when:

Foundational (needed for any task)
Frequently accessed
Stable (won't change)
Hard to find via search

Keep dynamic when:

Exhaustive reference (too large)
Version-specific
Situational (specific tasks only)
Well-indexed (easy to search)

Content Guidelines

Content Type	Local	Dynamic
Core concepts (3-5)	✅ Full
Hello world code	✅ Full
Common patterns (3-5)	✅ Full
Top API methods	Signature + example	Full docs via fetch
Best practices	Top 5 bullets	Search for more
Troubleshooting		Search queries
Full API reference		Doc links

Step 5: Validate

Review: Is local content sufficient for common tasks?
Test: Do suggested search queries return useful results?
Verify: Do code samples run without errors?

Common Investigation Patterns

For SDKs/Libraries

"{name} overview" → purpose, architecture
"{name} getting started quickstart" → setup steps
"{name} API reference" → core classes/methods
"{name} samples examples" → code patterns
"{name} best practices performance" → optimization

For Azure Services

"{service} overview features" → capabilities
"{service} quickstart {language}" → setup code
"{service} REST API reference" → endpoints
"{service} SDK {language}" → client library
"{service} pricing limits quotas" → constraints

For Frameworks/Platforms

"{framework} architecture concepts" → mental model
"{framework} project structure" → conventions
"{framework} tutorial walkthrough" → end-to-end flow
"{framework} configuration options" → customization

Example: Creating a "Semantic Kernel" Skill

Investigation

microsoft_docs_search(query="semantic kernel overview")
microsoft_docs_search(query="semantic kernel plugins functions")
microsoft_code_sample_search(query="semantic kernel", language="csharp")
microsoft_docs_fetch(url="https://learn.microsoft.com/semantic-kernel/overview/")

Generated Skill

semantic-kernel/
├── SKILL.md
└── sample_codes/
    ├── getting-started/
    │   └── hello-kernel.cs
    └── common-patterns/
        ├── chat-completion.cs
        └── function-calling.cs

Generated SKILL.md

---
name: semantic-kernel
description: Build AI agents with Microsoft Semantic Kernel. Use for LLM-powered apps with plugins, planners, and memory in .NET or Python.
---

# Semantic Kernel

Orchestration SDK for integrating LLMs into applications with plugins, planners, and memory.

## Key Concepts

- **Kernel**: Central orchestrator managing AI services and plugins
- **Plugins**: Collections of functions the AI can call
- **Planner**: Sequences plugin functions to achieve goals
- **Memory**: Vector store integration for RAG patterns

## Quick Start

See [getting-started/hello-kernel.cs](sample_codes/getting-started/hello-kernel.cs)

## Learn More

| Topic | How to Find |
|-------|-------------|
| Plugin development | `microsoft_docs_search(query="semantic kernel plugins custom functions")` |
| Planners | `microsoft_docs_search(query="semantic kernel planner")` |
| Memory | `microsoft_docs_fetch(url="https://learn.microsoft.com/en-us/semantic-kernel/frameworks/agent/agent-memory")` |

## CLI Alternative

If the Learn MCP server is not available, use the `mslearn` CLI instead:

| MCP Tool | CLI Command |
|----------|-------------|
| `microsoft_docs_search(query: "...")` | `mslearn search "..."` |
| `microsoft_code_sample_search(query: "...", language: "...")` | `mslearn code-search "..." --language ...` |
| `microsoft_docs_fetch(url: "...")` | `mslearn fetch "..."` |

Run directly with `npx @microsoft/learn-cli <command>` or install globally with `npm install -g @microsoft/learn-cli`.

Files

ATTRIBUTION.mdAdded by AutoGineer926 B
LICENSELicence file added by AutoGineer18.2 KiB
SKILL.md8.4 KiB
references/skill-templates.md7.7 KiB

Requirements and compatibility

Written for: Claude Code

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Claude Code frontmatter, Needs an MCP server, Needs Node.js

The author says: Primarily uses the Microsoft Learn MCP Server (https://learn.microsoft.com/api/mcp); if that is unavailable, fall back to the mslearn CLI (`npx @microsoft/learn-cli`).

Security

What our scanner noticed· Low risk

Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by

Microsoft Learn

Publisher

Microsoft Learn (Official)

Source

MicrosoftDocs/mcp · skills/microsoft-skill-creator · commit f0a9478

Licence

Creative Commons Attribution 4.0 International (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-09

AutoGineer is not affiliated with or endorsed by Microsoft Learn or Microsoft Learn.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download microsoft-skill-creator.zip

From the author

AutoGineer summary

What it does

When to use it

Advantages

Usage examples

Install

Documentation by Microsoft Learn

Microsoft Skill Creator

About Skills

Skill Structure

Key Principles

Learn MCP Tools

CLI Alternative

Creation Process

Step 1: Investigate the Topic

Investigation Checklist

Step 2: Clarify with User

Step 3: Generate the Skill

Generated Skill Structure

Step 4: Balance Local vs Dynamic Content

Content Guidelines

Step 5: Validate

Common Investigation Patterns

For SDKs/Libraries

For Azure Services

For Frameworks/Platforms

Example: Creating a "Semantic Kernel" Skill

Investigation

Generated Skill

Generated SKILL.md

Files

Requirements and compatibility

Security

Attribution and licence

Related skills

Setup Matt Pocock Skills

Writing For Agents

Loop Me

Writing Skills

Diagnosing Superpowers

Skill Creator

Download ZIP