slash-commands

A guide to slash commands in the GitHub Copilot app (opens in new tab)

Slash commands in the GitHub Copilot app provide quick, context-aware shortcuts for planning work, challenging decisions, automating implementation, and reviewing ideas. Unlike CLI commands, which manage terminal-oriented concerns such as directories and working paths, app commands focus on multi-session workflows and agent behavior. The post presents slash commands as a way to work faster while staying focused in the Copilot app. ## What Slash Commands Are - Type `/` in the chat composer to open an autocomplete menu of commands available in the current context. - The app manages project context visually, so commands such as `/add-dir` and `/cwd`—common in the CLI—are unnecessary. - Some commands, including `/clear` and `/model`, work in both the CLI and the app. - App-specific commands emphasize session navigation, project management, and controlling Copilot’s working mode. ## Planning Work with `/plan` `/plan` helps users think through a task before implementation and switches the session into Plan mode. - Break down new features by identifying files, components, dependencies, and implementation steps. - Prepare large refactors with an incremental migration strategy and risk assessment. - Investigate bugs by exploring possible causes and creating a diagnostic and repair plan. - Example: `/plan I need to add two-factor authentication to our application. Help me break down the work involved, identify what files need to change, and outline an implementation approach.` ## Challenging Ideas with `/spar` `/spar` acts as a critical reviewer, questioning assumptions and highlighting risks, tradeoffs, and edge cases. - Pressure-test architecture decisions such as using Redis for caching. - Compare alternatives like REST versus GraphQL or synchronous versus asynchronous processing. - Review database and infrastructure migration plans for rollout risks. - Evaluate proposed performance optimizations for hidden costs or unintended effects. ## Implementing with `/autopilot` `/autopilot` turns a high-level goal into an implementation workflow and switches the session into Autopilot mode. - Ask Copilot to implement features, update files, and modify tests. - Use it for multi-step maintenance work, including dependency upgrades, refactoring, and documentation updates. - Example tasks include adding CSV report exports or upgrading a React project while addressing breaking changes and running the test suite. ## Reviewing Ideas with `/rubber-duck` `/rubber-duck` provides an independent perspective for thinking through problems and debugging. The article introduces it as a more useful alternative to explaining an issue to a pet, but the supplied text ends before describing its full capabilities or examples. Use `/plan` to clarify the work, `/spar` to test the approach, and `/autopilot` to carry out the implementation. These commands complement the app’s visual workflow by making common Copilot interactions immediately accessible from the chat composer.

GitHub Copilot CLI for Beginners: Overview of common slash commands (opens in new tab)

GitHub Copilot CLI’s slash commands provide a central way to control sessions directly from the terminal. They help users select models, manage context, inspect changes, switch projects, resume work, and control permissions. The article recommends typing `/` to explore the available commands and build a more deliberate CLI workflow. ## Slash Commands as Copilot CLI Controls - Slash commands are built-in terminal controls for: - Guiding Copilot’s behavior - Inspecting project changes - Managing conversation context - Moving between sessions and repositories - Resetting tool permissions - Typing `/` displays a scrollable list of supported commands. ## Selecting a Model - `/model` opens the list of available models. - Model information includes: - Capabilities for lightweight tasks or deeper reasoning - Availability based on the user’s plan or organization - Cost multipliers indicating relative usage cost - Choosing an appropriate model can balance speed, quality, and cost. ## Managing Context and Tokens - `/context` shows remaining tokens, system usage, and available buffer. - `/compact` summarizes the current conversation to free context space without starting over. - Copilot may compact automatically near the context limit, but users can trigger it manually when changing tasks. - `/clear` completely resets the current session. ## Resuming Previous Sessions - `/resume` lists earlier local and remote sessions. - Users can select a session to review its history and continue where they left off. ## Reviewing Changes - `/diff` displays recent modifications made during the session. - This helps users inspect and validate Copilot’s changes before proceeding. ## Switching Projects - `/cwd` changes Copilot’s current working directory. - It allows users to move between repositories or project directories without exiting the CLI. ## Resetting Permissions - `/reset-allowed-tools` removes previously granted permissions for actions such as editing files. - This is useful when switching to a repository that requires more cautious access controls. Users should start by typing `/` in Copilot CLI to discover available commands, then use commands such as `/model`, `/context`, `/compact`, `/diff`, and `/cwd` to maintain control over their coding sessions.

Updated Requirements to How Apps Access Data in Servers (opens in new tab)

Discord is tightening how apps access message content, server member lists, and user presence data. Apps reaching 10,000 or more users must undergo review and renew approval annually, replacing the former threshold based on membership in 100 servers. Most users will notice no change, though apps that lose access may need to replace features such as text-command bots with slash commands. ## Updated Access Requirements - The changes affect access to: - Message content - Server member lists - User presence information, such as online or offline status - Apps serving fewer than 10,000 users are generally unaffected. - Apps reaching 10,000 or more users must complete Discord’s review process. - Approved apps must reapply every year to demonstrate that their data access remains necessary. ## Why Discord Is Changing the Rules - The previous review threshold was based on being installed in 100 or more servers. - Server count did not accurately reflect how many people an app could reach, especially when installed in one large community. - Annual reviews account for apps changing purpose over time. - Discord aims to ensure apps only retain access to data that is necessary, actively used, and consistent with their stated purpose. ## Impact on Developers and Users - Developers will receive notice and generally have 90 days to maintain access while applying or adapting their apps. - Developers may resubmit applications at any time. - Apps that lose access may continue working for features that do not depend on restricted data. - Text-based commands that require reading message content may need to be redesigned as slash commands. - Apps will not receive access to any new categories of data; the change concerns approval requirements and limitations. Discord recommends that developers review the updated requirements and that users inspect app profiles before deciding which apps to allow in their servers.

Run multiple agents at once with /fleet in Copilot CLI (opens in new tab)

GitHub Copilot CLI’s `/fleet` command lets multiple subagents work on independent tasks simultaneously rather than completing everything sequentially. An orchestrator decomposes the objective, manages dependencies, dispatches agents, and verifies their results. To benefit from parallel execution, users should define clear deliverables, boundaries, dependencies, and validation requirements. ## How `/fleet` Works - Breaks a task into discrete work items and identifies dependencies. - Runs independent items in parallel as background subagents. - Waits for completed work before dispatching dependent tasks. - Verifies results and assembles the final output. - Gives each subagent its own context window while sharing the same filesystem. - Prevents direct communication between subagents; the orchestrator coordinates them. ## Getting Started - Run `/fleet <objective prompt>` interactively, such as: ```bash /fleet Refactor the auth module, update tests, and fix the related docs in docs/auth/ ``` - For terminal-based non-interactive use: ```bash copilot -p "/fleet <YOUR TASK>" --no-ask-user ``` - The `--no-ask-user` option is required when no one is available to answer prompts. ## Writing Parallelizable Prompts - Define concrete deliverables such as individual files, test suites, or documentation sections. - Avoid vague requests that make it difficult to identify independent work. - Explicitly state: - File or module ownership - Constraints, such as avoiding dependency changes - Required tests, linting, or type checks - List dependencies so the orchestrator can serialize only the necessary work while parallelizing the rest. ## Using Custom Agents - Specialized agents can be defined in `.github/agents/`. - Agent definitions may specify: - Model - Tools - Role-specific instructions - Prompts can assign different agents to different tracks, such as using a technical writer for documentation and the default agent for code. - If no model is specified, the agent uses the current default model. ## Monitoring Fleet Execution - Review the initial decomposition to ensure the task has multiple independent tracks. - Use `/tasks` to inspect active background work. - Look for progress updates from separate tracks. - If work is proceeding sequentially, ask Copilot to decompose the task first and report each track’s status and blockers. ## Avoiding File Conflicts - Subagents share a filesystem without file locking. - If two agents edit the same file, the last completed write silently overwrites the other. - Assign distinct files or directories to each track. - For shared files, use temporary outputs and merge them afterward, or impose an explicit execution order. Use `/fleet` for well-partitioned work with clear ownership and dependencies. Careful prompt structure is essential: parallelism is most effective when agents can operate independently without competing for the same files.

How to Set Up Your Server’s Roles for Members, Mods &amp; Admins (opens in new tab)

Discord recommends organizing server permissions into three tiers: members, moderators, and administrators. Members receive essential communication and activity permissions, moderators get tools to manage conversations and users, and admins receive powerful server-management capabilities. Permissions should be tailored to each community and granted selectively, especially at the administrative level. ## Permissions for Server Members Members need permissions that support ordinary participation: - **General:** View channels, send messages, create public threads, send messages in threads, create invites, and change their own nickname. - **Voice:** Connect, speak, use video for webcams or screen sharing, use external sounds, use voice activity, and set voice-channel statuses. - **Apps:** Use application commands, Activities, and external apps. These permissions enable text chat, voice communication, streaming, games, and app-based interactions. ## Permissions for Moderators Moderators receive tools for keeping discussions and community activity orderly. - **Message and thread management:** Manage messages and threads, including deleting content, pinning messages, and archiving or renaming threads. - **Community management:** Create custom expressions, use broad mentions such as `@everyone`, kick or approve/reject members, ban members, apply timeouts, and manage other users’ nicknames. - **Oversight:** View the audit log to review actions taken on the server. - **Voice moderation:** Use Priority Speaker, mute or deafen members, and move participants between voice channels. - **Events:** Create, edit, manage, and delete community events. Most moderator actions can be reversed, though bans and large-scale mentions require particular care. ## Advanced Permissions for Server Administrators Administrative permissions affect major parts of the server, including messages, emojis, channels, and server settings. - Admin permissions should be enabled only when they are relevant to the community. - They should be assigned to a very limited group of trusted users. - **Manage Server** allows administrators to change core server settings, including the server name. The post’s main recommendation is to use the least amount of access necessary for each role, scaling permissions as the server grows and carefully restricting the most powerful controls.

How to Play Games, Listen to Music, and Improve Your Discord Server with Apps &amp; Activities (opens in new tab)

Discord’s Apps and Activities expand chats beyond messaging, offering games, music, collaboration tools, moderation features, and utilities on desktop and mobile. Users can discover them through the App Launcher or App Directory, add apps to servers or their personal accounts, and access saved apps through slash commands. Availability depends on server permissions and moderation settings. ## Discovering Apps and Activities - The **App Launcher** is available in text-chat bars and at the bottom of voice calls. - It provides: - Featured apps - Search for specific apps - Activities for games and shared experiences - Apps for servers and direct messages - The **App Directory** offers a larger catalog, including apps designed specifically for server communities. - Users can open it by selecting a server’s name and choosing **“App Directory.”** ## Adding Apps to a Server - Select **“Add App”** from the App Directory or an app’s profile. - Server apps can provide: - Additional moderation support - Reaction roles, allowing members to assign themselves roles by reacting to messages - Text-based games such as farming or fishing - Utilities such as on-demand cat-image commands - Discord also recommends considering built-in **Community server features** for moderation and reaction roles. ## Using Apps in Any Chat - Apps are no longer limited to server-based bots. - Users can select **“Add to My Apps”** and approve the required account permissions. - Personal apps then appear in the App Launcher and can be used across chats. - Pressing `/` opens the slash-command interface, where users can browse saved apps or enter their commands. ## Server Permissions and Restrictions - Some servers prevent members from launching apps that have not been approved or added by the server’s moderation team. - If an app or Activity cannot be used, users should check whether they have the **External Apps** and **Activities** permissions enabled. - Server-specific roles and moderation policies may still restrict access. Discord’s App Launcher and App Directory make it easy to find tools and shared activities, while personal app support allows users to use selected apps across conversations. Before adding an app, users should review its permissions and confirm that the server permits external apps or Activities.