MCP (Model Context Protocol) has made it much easier to connect Claude Code with the tools and systems developers already use.
A development team can connect Claude Code to GitHub, Jira, databases, monitoring platforms, CI/CD systems, or internal DevOps services through an MCP server. But MCP is not limited to tools that do something. An MCP server can also provide prompts — reusable workflows that developers can invoke when they need them.
An MCP server can expose reusable prompt templates. For example, imagine your company has a DevOps MCP server
This is the interesting part. MCP prompts exposed by connected MCP servers automatically become available as commands in Claude Code. They are dynamically discovered from connected servers.
Once an MCP server is connected to Claude Code, its prompts are dynamically discovered.
You can type / in Claude Code and see the available commands. MCP prompts appear using a naming pattern like
/mcp__servername__promptname
For example, a DevOps server named devops with an incident_response prompt would appear as /mcp__devops__incident_response
A deployment checklist could be
/mcp__devops__deploy_checklist
This is built into the MCP integration in Claude Code — you don’t have to manually recreate every MCP prompt as a local command.
Imagine your team has an internal DevOps MCP server.
It exposes tools such as
deploy_application
check_pipeline
get_deployment_status
fetch_logs
It also exposes prompts
deploy_checklist
incident_response
release_review
The tools give Claude the ability to interact with systems.
The prompts provide a predefined workflow or set of instructions for a particular task.
For example, incident_response could contain a workflow like
-
Identify the affected application
-
Check recent deployments
-
Review application logs
-
Check service health and metrics
-
Identify possible root cause
-
Recommend remediation
-
Prepare an incident summary
Instead of typing that workflow every time, the team can expose it through the MCP server.
There is a simple flow happening behind the scenes
At the protocol level, MCP clients can discover prompts with prompts/list and request a selected prompt with prompts/get. The resulting messages are then added to the conversation.
This is why an MCP prompt feels more like a reusable workflow than a normal API call.
This is probably the most important distinction to remember.
A tool represents something Claude can execute through the connected system.
For example
get_deployment_status() or fetch_logs()
These provide an actual capability to interact with an external system
A prompt gives Claude a predefined way of approaching a task.
incident_response
might say
Investigate the production incident by reviewing the deployment, logs, metrics, and recent changes before recommending remediation
Claude can then use the available tools to perform that investigation.
MCP treats prompts as user-controlled, while tools are designed to be invoked by the model when appropriate.
Another common source of confusion is CLAUDE.md.
CLAUDE.md is where you keep persistent instructions for your project.
-
Use Java 21
-
Follow our REST API conventions
-
Use JUnit 5
-
Run unit tests before creating a PR
-
Never commit secrets
These instructions establish the normal rules Claude should follow while working in the project.
An MCP prompt serves a different purpose.
Think of it this way
CLAUDE.md — Persistent project instructions
Claude Code Skill — Reusable local workflow
MCP PromptReusable — workflow provided by an MCP server
MCP Tool — Execute an action against an external system
MCP Resource — Provide external information/context
Claude Code now uses skills for reusable workflows and custom commands, while MCP handles connections to external services and capabilities.
MCP prompts aren’t necessarily fixed.
A prompt can define arguments that the developer supplies when invoking it.
/mcp__github__pr_review 456
Here 456 could represent the pull request number.
A DevOps workflow might look like
/mcp__devops__incident_response INC-4521
The prompt can use that argument when generating the instructions for Claude. Claude Code supports passing prompt arguments after the MCP command, and MCP defines arguments as part of the prompt metadata.
This makes MCP prompts useful for real enterprise workflows rather than just simple static text.
Let’s say your company has standardized its release process.
The DevOps MCP server provides
Prompts
deploy_checklist release_review incident_response
A developer is preparing a deployment.
They run
Claude receives the team’s standardized deployment workflow.It might then use MCP tools to
→ Check CI/CD status
→ Review deployment configuration
→ Check recent changes
→ Check application health
→ Validate rollback readiness
The important point is that the prompt defines the process, while the tools provide the capabilities needed to carry it out.
This becomes particularly valuable when a team has repeatable processes.
Instead of asking every developer to remember the company’s incident-management procedure, deployment checklist, or release-review process, those workflows can be made available through the MCP server.
/mcp__devops__deploy_checklist
/mcp__devops__incident_response
/mcp__devops__release_review
Now everyone starts from the same workflow. That can help teams standardize
Deployment → Incident response → Troubleshooting → Release validation → Security review
while still allowing Claude to use the appropriate tools and data sources. Prompt → Instructions / workflow
Resource → Information / context
Tool → Action / capability
And within Claude Code
MCP Server
↓
MCP Prompt
↓
/mcp__server__prompt
↓
Claude Code
So when you connect an MCP server, its prompts don’t sit hidden inside the server. Claude Code discovers them and makes them available as commands that you can explicitly invoke.
MCP prompts are a simple but powerful way to bring standardized workflows into Claude Code.
A team can keep its DevOps expertise in reusable prompts such as and expose them through an MCP server.
Developers then invoke them directly /mcp__devops__incident_response Claude receives the workflow, and MCP tools can provide the actual access to systems needed to complete the task.
Prompt tells Claude how to approach the work. Tool gives Claude the ability to perform the work.
That distinction is the key to understanding MCP prompts — and it’s also an important concept when working with Claude Code in real-world development environments.
MCP Prompts in Claude Code: A Simple Guide for Developers was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.