Teams App Developer

MicrosoftOfficialPublished by Microsoft

Skill
Tool integration
Software development
MIT
Medium risk

From the author

Builds, tests, and deploys Microsoft 365 apps and agents for Teams and Copilot. Includes sub-skills for project creation, local testing, cloud deployment, troubleshooting, and Slack-to-Teams migration. USE FOR: Teams agent, bot, tab, message extension, Declarative Agents, Custom Engine Agents, local testing, Agents Playground, Azure resource provision, remote deployment, Slack to Teams migration, cross-platform bot development, Block Kit to Adaptive Cards conversion. DO NOT USE FOR: general web development, non-bot/non-Teams projects.

— the description by Microsoft

AutoGineer summary

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

The teams-app-developer skill provides a structured framework for managing the lifecycle of Microsoft 365 agents and Teams applications. It leverages the ATK CLI to handle project scaffolding, local testing via the Agents Playground, cloud provisioning on Azure, and troubleshooting. The skill includes specialized guidance for migrating Slack bots to Teams, including converting Block Kit UI to Adaptive Cards, and provides access to an extensive library of micro-expert documentation for cross-platform development.

What it does

Scaffolds new Microsoft 365 agents and Teams applications from templates.
Facilitates local testing using the Agents Playground or Teams-specific environments.
Automates Azure resource provisioning and cloud deployment workflows.
Provides diagnostic procedures for common authentication and configuration errors.
Supports migration of Slack bots to the Teams platform.
Manages project configuration and environment variables for ATK-based projects.

When to use it

When starting a new Teams app, bot, or Declarative Agent project.
When you need to test an agent locally before deploying to the cloud.
When migrating existing Slack bots to the Microsoft Teams ecosystem.
When troubleshooting deployment or authentication issues in a Teams project.
When you need to provision Azure infrastructure for a Teams application.

Advantages

Streamlines the development lifecycle with standardized CLI commands.
Reduces development time by offering a local testing playground.
Provides expert-level guidance for complex cross-platform migrations.
Ensures consistent configuration management across development environments.
Includes robust error-handling protocols for common platform-specific pitfalls.

Usage examples

“Create a new Teams bot project using the default template.”: The agent will initialize a new project folder, configure the necessary YAML files, and guide you through the initial setup using the ATK CLI.
“How do I migrate my Slack bot to Microsoft Teams?”: The agent will initiate the slack-to-teams workflow, providing access to cross-platform bridging experts and guidance on converting UI components.
“My Teams bot is returning a 401 error, how do I fix it?”: The agent will trigger the troubleshooting workflow, checking your environment variables, tunnel status, and authentication configuration.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/microsoft/teams-app-developer/download

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

mkdir -p .agents/skills && unzip teams-app-developer.zip -d .agents/skills

Documentation by Microsoft

Microsoft 365 Agents Toolkit Skill

Build Microsoft 365 agents and Teams apps using the ATK CLI.

AI Behavior Guidelines

Testing Strategy: Recommend Agents Playground first (faster, no M365 needed). Use Teams workflow only if user explicitly requests it.
Environment Variables: NEVER hardcode secrets or make up placeholder values. Always ask users for real values.
Error Handling: Read error messages carefully. Check env/.env.local, .localConfigs, and atk auth list. Common pitfalls:
- AADSTS7000229 → aadApp/create missing generateServicePrincipal: true in YAML — add it and re-provision
- Missing TENANT_ID in .localConfigs → SDK uses wrong token authority → 401 from Bot Connector
- 401 persists after auth fix → devtunnel URL may be blacklisted — create a fresh tunnel
- See troubleshoot/troubleshoot.md for full diagnostic steps
Long-Running Commands — WAIT for completion:
- atk new, atk provision, atk deploy can take several minutes
- Always wait for completion before running the next step (timeout 120000ms+)
Local Service Startup — Hangs terminal (expected):
- npm run dev, npm start, python app.py, devtunnel host, etc. will hang — the process keeps running indefinitely
- ALWAYS run as a background process (isBackground=true) — NEVER use isBackground=false for these commands
- Do NOT wait for it to "finish" — verify startup by checking output for "listening on port" or tunnel URL
- If errors appear, read logs, diagnose, fix, restart
- Use a NEW terminal to launch Agents Playground or open Teams sideloading URL
Monitor App Logs: Periodically check background terminal output for runtime errors. If the app crashes, read the error, fix the root cause, and restart.
Telemetry Tagging: Before running any atk CLI commands, set the session environment variable so all CLI invocations are tagged as skill-initiated:
```
export ATK_CLI_SKILL=true
```
Run this once at the start of the session. All subsequent atk commands in the same terminal will inherit it.

ATK CLI Setup

atk --version  # Must be > 1.1.5-beta

If ATK is not found or version is too old:

npm i -g @microsoft/m365agentstoolkit-cli@beta

CLI Global Options

Option	Meaning	Recommendation
`-i`	Interactive mode	Always use `-i false` in automation to avoid hanging
`-f`	Project folder	Default to be current directory, used when specifying a custom folder. When scaffolding a new project, this is the parent folder where the project folder will be created under.
`-h`	Command help	Use `atk <command> -h` for quick syntax checks

Sub-Skills

Sub-Skill	When to Use	Reference
create-project	Scaffold new project from template, choose template, `atk new`	create-project/create-project.md
test-playground	Test locally with Agents Playground, `agentsplayground`, quick testing	test-playground/test-playground.md
test-teams	Run on Teams, devtunnel, sideload, Teams testing, test in Copilot	test-teams/test-teams.md
provision-deploy	Provision Azure resources, deploy to cloud, `atk provision`, `atk deploy`	provision-deploy/provision-deploy.md
troubleshoot	Fix errors, 401, port conflicts, YAML errors, stale bots	troubleshoot/troubleshoot.md
slack-to-teams	Migrate Slack bot to Teams, cross-platform bridging, Block Kit to Adaptive Cards	slack-to-teams/SKILL.md

MANDATORY: Before executing any workflow, read the corresponding sub-skill document.

Shared References

manifest-and-yaml.md — Project files, YAML config, env vars, .localConfigs flow
commands.md — ATK CLI commands: package, validate, share, collaborate
templates.md — Complete template catalog with language support
experts/ — 100+ micro-expert files: Teams SDK, Slack SDK, cross-platform bridging, deploy, AI models, security, language conversion
docs/ — Platform comparison guides: UI, messaging, identity, infrastructure, feature gaps

Workflow Chains

Match user intent to the smallest valid workflow.

User Intent	Workflow (read in order)
Build new app from scratch	create-project → test-playground
Test existing project locally	test-playground (recommended) or test-teams
Deploy to Azure	provision-deploy
Fix broken bot	troubleshoot → re-test
Migrate Slack bot to Teams	slack-to-teams

MANDATORY: Before executing any slack-to-teams workflow, read slack-to-teams/SKILL.md first. The sub-skill contains a routed expert system with 100+ micro-expert files for cross-platform bot development.

ATK Project Context Resolution

Resolve config values only when missing. If a value is already known in the session, reuse it.

Step 1: Detect ATK Project

If m365agentstoolkit*.yml exists in the current folder, treat it as an ATK project and parse configuration.

Step 2: Resolve Common Configuration

Resolve variables referenced in m365agentstoolkit*.yml. Common variables: AZURE_OPENAI_API_KEY AZURE_OPENAI_ENDPOINT AZURE_OPENAI_DEPLOYMENT_NAME

Step 3: Collect Missing Values

If required values are missing, ask the user for only the missing ones.

Refer to manifest-and-yaml.md for full config-file details.

Files

ATTRIBUTION.mdAdded by AutoGineer906 B
LICENSELicence file added by AutoGineer1.1 KiB
SKILL.md7.6 KiB
create-project/create-project.md8.1 KiB
docs/README.md2.8 KiB
docs/advanced-features.md7.0 KiB
docs/feature-gaps.md46.3 KiB
docs/files-and-links.md4.2 KiB
docs/identity-and-auth.md4.3 KiB
docs/infrastructure.md6.7 KiB
docs/interactive-responses.md4.4 KiB
docs/messaging-and-commands.md4.5 KiB
docs/middleware-and-handlers.md4.4 KiB
docs/ui-components.md6.9 KiB
docs/workflows.md14.4 KiB
experts/README.md8.6 KiB
experts/_expert-ts.md2.2 KiB
experts/analyzer.md14.0 KiB
experts/bridge/app-distribution-packaging-ts.md14.2 KiB
experts/bridge/channel-ops-graph-ts.md15.4 KiB
experts/bridge/commands-slash-text-ts.md18.5 KiB
experts/bridge/cross-platform-advisor-ts.md36.4 KiB
experts/bridge/cross-platform-architecture-ts.md8.3 KiB
experts/bridge/events-activities-ts.md22.4 KiB
experts/bridge/files-upload-download-ts.md17.2 KiB
experts/bridge/identity-oauth-bridge-ts.md19.8 KiB
experts/bridge/index.md13.0 KiB
experts/bridge/infra-compute-ts.md14.6 KiB
experts/bridge/infra-observability-ts.md14.0 KiB
experts/bridge/infra-secrets-config-ts.md13.2 KiB
experts/bridge/infra-storage-ts.md14.3 KiB
experts/bridge/interactive-responses-ts.md19.6 KiB
experts/bridge/link-unfurl-preview-ts.md17.1 KiB
experts/bridge/middleware-handlers-ts.md15.4 KiB
experts/bridge/python-cross-platform.md9.3 KiB
experts/bridge/rate-limiting-resilience-ts.md17.6 KiB
experts/bridge/rest-only-integration-ts.md8.4 KiB
experts/bridge/scheduling-deferred-send-ts.md17.8 KiB
experts/bridge/shortcuts-extensions-ts.md17.5 KiB
experts/bridge/transport-socketmode-https-ts.md14.3 KiB
experts/bridge/ui-app-home-personal-tab-ts.md14.5 KiB
experts/bridge/ui-block-kit-adaptive-cards-ts.md21.5 KiB
experts/bridge/ui-legacy-attachments-cards-ts.md11.2 KiB
experts/bridge/ui-modals-dialogs-ts.md21.4 KiB
experts/bridge/workflow.composable-platform-ts.md13.7 KiB
experts/bridge/workflows-automation-ts.md14.3 KiB
experts/builder.md11.1 KiB
experts/convert/bulk-conversion-strategy-ts.md12.8 KiB
experts/convert/dependency-mapping-ts.md8.3 KiB
experts/convert/index.md3.5 KiB
experts/convert/java-to-ts-ts.md20.6 KiB
experts/convert/js-to-ts-ts.md6.2 KiB
experts/convert/json-serialization-ts.md11.0 KiB
experts/convert/kotlin-to-ts-ts.md11.2 KiB
experts/convert/ruby-to-ts-ts.md9.7 KiB
experts/convert/type-mapping-ts.md10.1 KiB
experts/deploy/aws-bot-deploy-ts.md14.6 KiB
experts/deploy/aws-cli-reference-ts.md52.4 KiB
experts/deploy/azure-bot-deploy-ts.md15.4 KiB
experts/deploy/azure-cli-reference-ts.md16.9 KiB
experts/deploy/index.md4.6 KiB
experts/fallback.md2.1 KiB
experts/index.md18.9 KiB
experts/models/anthropic-ts.md7.8 KiB
experts/models/bedrock-ts.md9.9 KiB
experts/models/foundry-cloud-ts.md8.1 KiB
experts/models/foundry-local-ts.md10.6 KiB
experts/models/index.md5.8 KiB
experts/models/openai-azure-openai-ts.md8.3 KiB
experts/models/oss-openai-compatible-ts.md10.7 KiB
experts/models/transformers-js-ts.md11.6 KiB
experts/prompt-engineer.md14.7 KiB
experts/researcher.md2.8 KiB
experts/security/index.md1.2 KiB
experts/security/input-validation-ts.md13.8 KiB
experts/security/secrets-ts.md13.9 KiB
experts/slack/bolt-assistant-ts.md9.9 KiB
experts/slack/bolt-events-ts.md9.3 KiB
experts/slack/bolt-java.md8.9 KiB
experts/slack/bolt-oauth-distribution-ts.md10.9 KiB
experts/slack/bolt-python.md9.5 KiB
experts/slack/cli.app-management.md7.9 KiB
experts/slack/cli.datastore-env.md8.6 KiB
experts/slack/cli.getting-started.md8.0 KiB
experts/slack/cli.local-dev-deploy.md8.4 KiB
experts/slack/cli.manifest-triggers.md9.9 KiB
experts/slack/index.md8.9 KiB
experts/slack/runtime.ack-rules-ts.md9.8 KiB
experts/slack/runtime.bolt-foundations-ts.md10.7 KiB
experts/slack/runtime.shortcuts-ts.md11.0 KiB
experts/slack/runtime.slash-commands-ts.md11.6 KiB
experts/slack/runtime.socket-mode-ts.md9.5 KiB
experts/slack/ui.block-kit-ts.md11.5 KiB
experts/slack/ui.modals-lifecycle-ts.md13.3 KiB
experts/slack/web-api-proactive-ts.md11.0 KiB
experts/slack/workflow.slack-automations-ts.md10.2 KiB
experts/teams/a2a.client-basics-ts.md9.7 KiB
experts/teams/a2a.orchestrator-patterns-ts.md12.7 KiB
experts/teams/a2a.server-basics-ts.md11.4 KiB
experts/teams/ai.chatprompt-basics-ts.md8.1 KiB
experts/teams/ai.citations-feedback-ts.md6.9 KiB
experts/teams/ai.conversational-query-ts.md14.2 KiB
experts/teams/ai.function-calling-design-ts.md9.0 KiB
experts/teams/ai.function-calling-implementation-ts.md7.7 KiB
experts/teams/ai.memory-localmemory-ts.md7.3 KiB
experts/teams/ai.model-setup-ts.md6.6 KiB
experts/teams/ai.rag-retrieval-ts.md7.4 KiB
experts/teams/ai.rag-vectorstores-ts.md8.5 KiB
experts/teams/ai.streaming-ts.md6.9 KiB
experts/teams/auth.oauth-sso-ts.md10.1 KiB
experts/teams/compat.botbuilder-interop-ts.md14.6 KiB
experts/teams/dev.debug-test-ts.md14.1 KiB
experts/teams/graph.usergraph-appgraph-ts.md9.0 KiB
experts/teams/index.md9.8 KiB
experts/teams/mcp.client-basics-ts.md9.5 KiB
experts/teams/mcp.expose-chatprompt-tools-ts.md9.5 KiB
experts/teams/mcp.security-ts.md10.4 KiB
experts/teams/mcp.server-basics-ts.md9.9 KiB
experts/teams/project.scaffold-files-ts.md12.2 KiB
experts/teams/runtime.app-init-ts.md10.9 KiB
experts/teams/runtime.manifest-ts.md12.3 KiB
experts/teams/runtime.proactive-messaging-ts.md12.6 KiB
experts/teams/runtime.routing-handlers-ts.md12.3 KiB
experts/teams/state.storage-patterns-ts.md9.4 KiB
experts/teams/teams-dotnet.md8.2 KiB
experts/teams/teams-python.md8.3 KiB
experts/teams/ui.adaptive-cards-ts.md12.9 KiB
experts/teams/ui.dialogs-task-modules-ts.md15.1 KiB
experts/teams/ui.message-extensions-ts.md15.6 KiB
experts/teams/workflow.approvals-inline-ts.md12.4 KiB
experts/teams/workflow.message-native-records-ts.md10.6 KiB
experts/teams/workflow.sharepoint-lists-ts.md9.0 KiB
experts/teams/workflow.state-driven-events-ts.md12.2 KiB
experts/teams/workflow.triggers-compose-ts.md10.3 KiB
experts/update-experts.md10.0 KiB
provision-deploy/provision-deploy.md4.3 KiB
test-playground/playground-cli.md4.6 KiB
test-playground/playground.md4.5 KiB
test-playground/test-playground.md1.1 KiB
test-teams/test-teams.md4.9 KiB
toolkit/README.md4.2 KiB
toolkit/commands.md2.6 KiB
toolkit/environments.md12.6 KiB
toolkit/lifecycle-cli.md17.6 KiB
toolkit/manifest-and-yaml.md6.0 KiB
toolkit/playground.md7.6 KiB
toolkit/publish.md9.3 KiB
toolkit/templates.md6.7 KiB
troubleshoot/troubleshoot.md20.2 KiB

experts/bridge/app-distribution-packaging-ts.md

app-distribution-packaging-ts

purpose

Bridges Slack App Directory distribution and Teams app packaging / Admin Center publishing for cross-platform bots targeting Slack, Teams, or both.

rules

Slack App Directory → Teams App Store (Partner Center). Slack apps are listed in the Slack App Directory for public distribution. Teams apps are published to the Microsoft Teams App Store via Partner Center. The review and submission process is completely different — Partner Center requires a Microsoft Partner Network account and compliance with Teams store validation policies. learn.microsoft.com -- Publish to store
Slack OAuth install flow → Azure Bot registration (no per-workspace tokens). Slack apps use OAuth to install into each workspace, generating per-workspace xoxb- tokens stored in an InstallationStore. Teams bots use Azure Bot Framework credentials (CLIENT_ID/CLIENT_SECRET) that work across all tenants. There are no per-workspace tokens to manage. Delete InstallationStore and all OAuth install flow code. learn.microsoft.com -- Bot registration
Slack InstallationStore → conversation reference storage. Slack's InstallationStore persists tokens per workspace for API calls. Teams doesn't need per-workspace tokens, but you still need to store conversation references for proactive messaging. Replace InstallationStore with a conversation reference store keyed by conversationId. learn.microsoft.com -- Proactive messages
Slack org-level install → Teams Admin Center tenant-wide deployment. Slack Enterprise Grid supports org-level app installation. In Teams, tenant-wide deployment is done via the Teams Admin Center by an IT admin: Manage Apps → Upload/Approve → Deploy to users/groups. No code changes needed — the admin controls distribution. learn.microsoft.com -- Admin Center
Development install → Teams sideloading. Slack development apps are installed via the app's manage page or OAuth URL. Teams development apps are sideloaded: upload the app package (ZIP with manifest + icons) directly into Teams. Sideloading must be enabled by the tenant admin. learn.microsoft.com -- Sideloading
Agents Toolkit simplifies packaging, provisioning, and deployment. Agents Toolkit (VS Code extension or CLI atk) automates: Azure resource provisioning, app package generation, sideloading, and publishing. It replaces the manual Azure Portal + zip file workflow. Use atk package to generate the app package and atk publish to submit. learn.microsoft.com -- Agents Toolkit
Multi-tenant Slack app → Azure AD multi-tenant app registration. Slack multi-workspace apps use the App Directory + OAuth per workspace. Teams multi-tenant bots use a single Azure AD app registration with signInAudience: "AzureADMultipleOrgs". Any tenant can install the bot without workspace-specific OAuth. learn.microsoft.com -- Multi-tenant
Slack app manifest (manifest.json) → Teams app manifest (manifest.json in app package). Both platforms use JSON manifests but with completely different schemas. Slack's manifest includes OAuth scopes, event subscriptions, slash commands. Teams manifest includes bots, composeExtensions, staticTabs, webApplicationInfo, validDomains. No automatic conversion exists. learn.microsoft.com -- Manifest schema
Slack app icons (512x512 + workspace-specific) → Teams icons (color 192x192 + outline 32x32). Teams requires exactly two icon files in the app package: a full-color icon (192x192 PNG) and an outline/monochrome icon (32x32 PNG with transparent background). The outline icon is used in the Teams activity bar. learn.microsoft.com -- App icons
Slack app review (hours-days) vs Teams store review (1-2 weeks). Slack's App Directory review is relatively fast. Teams App Store review via Partner Center is more rigorous and can take 1-2 weeks. Plan for revision cycles — common rejection reasons include missing privacy policy URL, incomplete manifest, and accessibility issues. learn.microsoft.com -- Store validation
Reverse direction (Teams → Slack): For Teams → Slack, map Teams manifest to Slack app manifest, and Teams Admin Center publishing to Slack App Directory submission. Azure Bot registration credentials map to Slack OAuth install flow with InstallationStore for per-workspace tokens. Teams sideloading maps to Slack development install via OAuth URL. The Teams color/outline icon pair maps to Slack's single 512x512 app icon. Azure AD multi-tenant registration maps to Slack App Directory multi-workspace distribution with per-workspace OAuth.

patterns

InstallationStore removal + conversation reference storage

Slack (before):

import { App, Installation, InstallationQuery } from "@slack/bolt";

// InstallationStore — persist per-workspace tokens
const installationStore = {
  storeInstallation: async (installation: Installation) => {
    const teamId = installation.team?.id ?? installation.enterprise?.id;
    await db.put(`installation:${teamId}`, JSON.stringify(installation));
  },
  fetchInstallation: async (query: InstallationQuery<boolean>) => {
    const teamId = query.teamId ?? query.enterpriseId;
    const data = await db.get(`installation:${teamId}`);
    return JSON.parse(data) as Installation;
  },
  deleteInstallation: async (query: InstallationQuery<boolean>) => {
    const teamId = query.teamId ?? query.enterpriseId;
    await db.delete(`installation:${teamId}`);
  },
};

const app = new App({
  signingSecret: process.env.SLACK_SIGNING_SECRET!,
  clientId: process.env.SLACK_CLIENT_ID!,
  clientSecret: process.env.SLACK_CLIENT_SECRET!,
  stateSecret: process.env.SLACK_STATE_SECRET!,
  installationStore,
  scopes: ["chat:write", "commands", "channels:history"],
});

// Use workspace-specific token for API calls
app.message(/hello/i, async ({ say, client }) => {
  // client automatically uses the workspace's xoxb token
  await say("Hello!");
});

Teams (after):

import { App } from "@microsoft/teams.apps";
import { ConsoleLogger } from "@microsoft/teams.common";

// No InstallationStore needed — single credential set works for all tenants
const app = new App({
  clientId: process.env.CLIENT_ID,      // Azure Bot app ID
  clientSecret: process.env.CLIENT_SECRET, // Azure Bot secret
  tenantId: process.env.TENANT_ID,       // or "common" for multi-tenant
  logger: new ConsoleLogger("my-bot", { level: "info" }),
});

// Store conversation references instead of installations
// Needed for proactive messaging (the only thing that replaced InstallationStore's purpose)
const conversationRefs = new Map<string, {
  conversationId: string;
  serviceUrl: string;
  tenantId: string;
}>();

app.on("install.add", async ({ activity, send }) => {
  // Persist conversation reference for future proactive messaging
  const convId = activity.conversation?.id ?? "";
  conversationRefs.set(convId, {
    conversationId: convId,
    serviceUrl: (activity as any).serviceUrl,
    tenantId: activity.channelData?.tenant?.id ?? "",
  });
  await send("Bot installed! I'm ready to help.");
});

app.on("install.remove", async ({ activity }) => {
  const convId = activity.conversation?.id ?? "";
  conversationRefs.delete(convId);
});

app.message(/hello/i, async ({ send }) => {
  // No workspace token lookup needed — just send
  await send("Hello!");
});

app.start(3978);

App Directory → Admin Center deployment

Slack — submit app to Slack App Directory via api.slack.com dashboard. Users install via the directory.

Teams — multiple distribution paths:

# Option 1: Sideload for development
# Build the app package (manifest.json + icons in a ZIP)
atk package --env dev -i false

# Upload to Teams:
# Teams → Apps → Manage your apps → Upload a custom app

# Option 2: Submit to organization's app catalog
atk publish --env staging
# IT admin approves in Teams Admin Center → Manage Apps

# Option 3: Submit to public Teams App Store (Partner Center)
# 1. Create Partner Center account
# 2. Submit app package for review
# 3. Review takes 1-2 weeks
# 4. Once approved, appears in Teams App Store

# Option 4: Tenant-wide deployment (admin pushes to all users)
# Teams Admin Center → Manage Apps → find app → Assign to users/groups
# No code changes — purely admin configuration

Teams app package structure:

my-teams-bot.zip
├── manifest.json       # Teams-specific manifest (not Slack's)
├── color.png           # 192x192 full-color icon
└── outline.png         # 32x32 monochrome outline icon

Distribution model mapping table

Slack Distribution	Teams Equivalent	Notes
App Directory (public listing)	Teams App Store via Partner Center	Requires partner account; 1-2 week review
OAuth install flow (per-workspace)	Azure Bot registration (global)	No per-workspace tokens
`InstallationStore`	Conversation reference store	Only for proactive messaging
Org-level install (Enterprise Grid)	Teams Admin Center tenant-wide deploy	Admin pushes to users/groups
Development install (OAuth URL)	Sideloading (upload ZIP)	Admin must enable sideloading
`manifest.json` (Slack schema)	`manifest.json` (Teams schema)	Completely different schemas
App icon (512x512)	Color (192x192) + Outline (32x32)	Two icons required
OAuth scopes (`chat:write`, etc.)	Azure AD permissions + RSC	Different permission model
Multi-workspace (App Directory)	Multi-tenant (Azure AD)	`signInAudience: "AzureADMultipleOrgs"`

pitfalls

Trying to port the InstallationStore: Teams does not need per-workspace token storage. Developers who port InstallationStore logic create unnecessary complexity. Delete it and use conversation reference storage only for proactive messaging.
Sideloading disabled by default in many orgs: IT admins may have disabled sideloading. If the developer can't upload the app package, they need to request sideloading permission from their Teams admin. This is a common blocker during development.
Partner Center account setup takes time: Publishing to the Teams App Store requires a Microsoft Partner Network account. Account verification can take days. Start the Partner Center registration early in the migration timeline.
Icon format rejection: Teams requires exactly two PNG icons with specific dimensions. The outline icon must have a transparent background. Submitting icons in the wrong format or size causes app package validation failure.
Multi-tenant vs single-tenant confusion: Slack apps are inherently multi-workspace when listed in the App Directory. Teams apps must explicitly set multi-tenant in the Azure AD app registration. A single-tenant registration only works in the developer's own organization.
OAuth scopes → RSC permissions: Slack OAuth scopes (channels:history, chat:write) have no direct mapping to Azure AD permissions. Teams uses a combination of Azure AD API permissions and Resource-Specific Consent (RSC) permissions declared in the manifest. This is the most conceptually different part of the migration.

references

instructions

Use this expert when adding cross-platform support in either direction for app distribution and packaging. It covers: Slack App Directory bridged to Teams App Store (Partner Center), OAuth install flow vs Azure Bot registration, InstallationStore vs conversation reference storage, org-level deployment via Teams Admin Center, sideloading for development, Agents Toolkit for packaging, multi-tenant Azure AD registration, icon requirements, store review timelines, and reverse mapping from Teams manifest/Admin Center back to Slack app manifest and App Directory submission. Pair with identity-oauth-bridge-ts.md for the identity/OAuth model change, ../teams/runtime.manifest-ts.md for Teams manifest creation, and ../teams/runtime.proactive-messaging-ts.md for conversation reference storage patterns.

research

Deep Research prompt:

"Write a micro expert for bridging Slack App Directory distribution and Microsoft Teams app packaging / Admin Center publishing in either direction. Cover: App Directory vs Teams App Store (Partner Center), OAuth install flow vs Azure Bot registration, InstallationStore vs conversation reference storage, org-level install vs Teams Admin Center, sideloading, Agents Toolkit packaging, multi-tenant Azure AD app registration, icon requirements, manifest schema differences, OAuth scope to RSC mapping, store review timeline, and reverse mapping from Teams manifest/publishing back to Slack app manifest and App Directory submission. Include code examples and a mapping table."

Requirements and compatibility

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: Needs an API key, Needs Python, Needs Node.js

Security

What our scanner noticed· Medium risk

Possible data-exfiltration endpoints
Instructions that use the network
Downloads piped into a shell

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

Publisher

Microsoft (Official)

Source

microsoft/skills · .github/plugins/microsoft-365-agents-toolkit/skills/teams-app-developer · commit 0696600

Licence

MIT License (redistribution allowed)

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

Synced

2026-11-08

AutoGineer is not affiliated with or endorsed by Microsoft.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download teams-app-developer.zip