Microsoft Skill Creator
Microsoft LearnOfficialPublished by Microsoft Learn
- Skill
- Workflow
- Agent tooling
- CC-BY-4.0
- Low risk
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://mp-staging.autogineer.com/agent-skills/microsoftdocs/microsoft-skill-creator/downloadUnzip 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:
nameanddescriptiondetermine when the skill triggers—be clear and comprehensiveConcise 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" → optimizationFor 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" → constraintsFor Frameworks/Platforms
"{framework} architecture concepts" → mental model
"{framework} project structure" → conventions
"{framework} tutorial walkthrough" → end-to-end flow
"{framework} configuration options" → customizationExample: 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.csGenerated 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
references/skill-templates.md
Skill Templates
Ready-to-use templates for different types of Microsoft technologies.
CLI Alternative for MCP Tools
All templates below use MCP tool calls (e.g., microsoft_docs_search, microsoft_docs_fetch, microsoft_code_sample_search). If the Learn MCP server is not available, replace them with CLI equivalents:
| 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.
Template 1: SDK/Library Skill
For client libraries, SDKs, and programming frameworks.
---
name: {sdk-name}
description: {What it does}. Use when agents need to {primary task} with {technology context}. Supports {languages/platforms}.
---
# {SDK Name}
{One paragraph: what it is, why it exists, when to use it}
## Installation
{Package manager commands for supported languages}
## Key Concepts
{3-5 essential concepts, one paragraph each max}
### {Concept 1}
{Brief explanation}
### {Concept 2}
{Brief explanation}
## Quick Start
{Minimal working example - inline if <30 lines, otherwise reference sample_codes/}
## Common Patterns
### {Pattern 1: e.g., "Basic CRUD"}
```{language}
{code}{Pattern 2: e.g., "Error Handling"}
{code}API Quick Reference
| Class/Method | Purpose | Example |
|---|---|---|
| {name} | {what it does} | {usage} |
For full API documentation:
microsoft_docs_search(query="{sdk} {class} API reference")microsoft_docs_fetch(url="{url}")
Best Practices
Do: {recommendation}
Do: {recommendation}
Avoid: {anti-pattern}
See best-practices.md for detailed guidance.
Learn More
| Topic | How to Find |
|---|---|
| {Advanced topic 1} | microsoft_docs_search(query="{sdk} {topic}") |
| {Advanced topic 2} | microsoft_docs_fetch(url="{url}") |
| {Code examples} | microsoft_code_sample_search(query="{sdk} {scenario}", language="{lang}") |
---
## Template 2: Azure Service Skill
For Azure services and cloud resources.
```markdown
---
name: {service-name}
description: Work with {Azure Service}. Use when agents need to {primary capabilities}. Covers provisioning, configuration, and SDK usage.
---
# {Azure Service Name}
{One paragraph: what the service does, primary use cases}
## Overview
- **Category**: {Compute/Storage/AI/Networking/etc.}
- **Key capability**: {main value proposition}
- **When to use**: {scenarios}
## Getting Started
### Prerequisites
- Azure subscription
- {Other requirements}
### Provisioning
{CLI/Portal/Bicep snippet for creating the resource}
## SDK Usage ({Language})
### Installation{package install command}
### Authentication
```{language}
{auth code pattern}Basic Operations
{CRUD or primary operations}Key Configurations
| Setting | Purpose | Default |
|---|---|---|
| {setting} | {what it controls} | {value} |
Pricing & Limits
Pricing model: {consumption/tier-based/etc.}
Key limits: {important quotas}
For current pricing: microsoft_docs_search(query="{service} pricing")
Common Patterns
{Pattern 1}
{Code or configuration}
{Pattern 2}
{Code or configuration}
Troubleshooting
| Issue | Solution |
|---|---|
| {Common error} | {Fix} |
For more issues: microsoft_docs_search(query="{service} troubleshoot {symptom}")
Learn More
| Topic | How to Find |
|---|---|
| REST API | microsoft_docs_fetch(url="{url}") |
| ARM/Bicep | microsoft_docs_search(query="{service} bicep template") |
| Security | microsoft_docs_search(query="{service} security best practices") |
---
## Template 3: Framework/Platform Skill
For development frameworks and platforms (e.g., ASP.NET, MAUI, Blazor).
```markdown
---
name: {framework-name}
description: Build {type of apps} with {Framework}. Use when agents need to create, modify, or debug {framework} applications.
---
# {Framework Name}
{One paragraph: what it is, what you build with it, why choose it}
## Project Structure
{typical-project}/ ├── {folder}/ # {purpose} ├── {file} # {purpose} └── {file} # {purpose}
## Getting Started
### Create New Project
```bash
{CLI command to scaffold}Project Configuration
{Key files to configure and what they control}
Core Concepts
{Concept 1: e.g., "Components"}
{Explanation with minimal code example}
{Concept 2: e.g., "Routing"}
{Explanation with minimal code example}
{Concept 3: e.g., "State Management"}
{Explanation with minimal code example}
Common Patterns
{Pattern 1}
{code}{Pattern 2}
{code}Configuration Options
| Setting | File | Purpose |
|---|---|---|
| {setting} | {file} | {what it does} |
Deployment
{Brief deployment guidance or reference}
For detailed deployment: microsoft_docs_search(query="{framework} deploy {target}")
Learn More
| Topic | How to Find |
|---|---|
| {Advanced feature} | microsoft_docs_search(query="{framework} {feature}") |
| {Integration} | microsoft_docs_fetch(url="{url}") |
| {Samples} | microsoft_code_sample_search(query="{framework} {scenario}") |
---
## Template 4: API/Protocol Skill
For APIs, protocols, and specifications (e.g., Microsoft Graph, OOXML).
```markdown
---
name: {api-name}
description: Interact with {API/Protocol}. Use when agents need to {primary operations}. Covers authentication, endpoints, and common operations.
---
# {API/Protocol Name}
{One paragraph: what it provides access to, primary use cases}
## Authentication
{Auth method and code pattern}
## Base Configuration
- **Base URL**: `{url}`
- **Version**: `{version}`
- **Format**: {JSON/XML/etc.}
## Common Endpoints/Operations
### {Operation 1: e.g., "List Items"}{HTTP method} {endpoint}
```{language}
{SDK code}{Operation 2: e.g., "Create Item"}
{HTTP method} {endpoint}{SDK code}Request/Response Patterns
Pagination
{How to handle pagination}
Error Handling
{Error format and common codes}
Quick Reference
| Operation | Endpoint/Method | Notes |
|---|---|---|
| {op} | {endpoint} | {note} |
Permissions/Scopes
| Operation | Required Permission |
|---|---|
| {op} | {permission} |
Learn More
| Topic | How to Find |
|---|---|
| Full endpoint reference | microsoft_docs_fetch(url="{url}") |
| Permissions | microsoft_docs_search(query="{api} permissions {resource}") |
| SDKs | microsoft_docs_search(query="{api} SDK {language}") |
---
## Choosing a Template
| Technology Type | Template | Examples |
|-----------------|----------|----------|
| Client library, NuGet/npm package | SDK/Library | Semantic Kernel, Azure SDK, MSAL |
| Azure resource | Azure Service | Cosmos DB, Azure Functions, App Service |
| App development framework | Framework/Platform | ASP.NET Core, Blazor, MAUI |
| REST API, protocol, specification | API/Protocol | Microsoft Graph, OOXML, FHIR |
## Customization Guidelines
Templates are starting points. Customize by:
1. **Adding sections** for unique aspects of the technology
2. **Removing sections** that don't apply
3. **Adjusting depth** based on complexity (more concepts for complex tech)
4. **Adding reference files** for detailed content that doesn't fit in SKILL.md
5. **Adding sample_codes/** for working examples beyond inline snippetsRequirements 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
AutoGineer is not affiliated with or endorsed by Microsoft Learn.
Related skills
Setup Matt Pocock Skills
Matt Pocock· Community
Initializes repository configuration for Matt Pocock's engineering agent skills.
Agent toolingClaude CodeClaude appsOpenAI Codex+14 moreMITGitHub stars of the source repository317.5k
Writing For Agents
Matt Pocock· Community
A framework for writing effective, maintainable documentation and skill definitions for AI agents.
Agent toolingClaude CodeClaude appsOpenAI Codex+14 moreMITGitHub stars of the source repository317.5k
Loop Me
Matt Pocock· Community
A systematic grilling process to define and document recurring workflow specifications.
Agent toolingClaude CodeClaude appsOpenAI Codex+14 moreMITGitHub stars of the source repository317.5k
Writing Skills
Jesse Vincent (obra)· Community
A Test-Driven Development framework for creating, verifying, and maintaining robust agent skills.
Agent toolingClaude CodeClaude appsOpenAI Codex+14 moreMITLow riskHas scriptsGitHub stars of the source repository314k
Diagnosing Superpowers
Jesse Vincent (obra)· Community
A systematic workflow for investigating and reporting issues within AI agent sessions.
Agent toolingClaude CodeClaude appsOpenAI Codex+14 moreMITGitHub stars of the source repository314k
Skill Creator
AnthropicOfficial
A comprehensive framework for building, testing, evaluating, and optimizing AI agent skills.
Agent toolingClaude CodeClaude appsOpenAI Codex+14 moreApache-2.0Low riskHas scriptsGitHub stars of the source repository188.6k
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download microsoft-skill-creator.zip