Make your AI prompts collaborative with VS Code and Promptitude

A version of this article originally appeared in my personal blog on November 4, 2025

If you're working in a project that is in active development, it's very likely you perform many repetitive tasks that you have done before and will inevitably need to do again in the future. For instance, perhaps you often need to add functionality to your application that calls a given REST API, deserializes its JSON response into a DTO (Data Transfer Object), and then transforms it into a domain object that your app can consume. While the exact endpoint, data payload, and purpose may change from one instance to another, the actual steps in the implementation often remain largely the same.

This type of process—fetching data, parsing it, and integrating it into your domain model—is so common in software development that it forms a core part of many engineers’ daily workflow. Over time, developers begin to recognize patterns in these tasks, which opens the door to automation. Automating repetitive processes not only saves time but also reduces errors, since standardized, reusable workflows ensure more consistent results across different parts of a project.

Enter reusable prompts

If you're using Visual Studio Code for development and are doing AI-assisted development, you can go a step further by leveraging prompt files. Prompt files are essentially reusable instructions that can be fed to Copilot to perform specific, structured tasks over and over again, without having to rewrite your request from scratch each time.

Think of them as snippets or templates—except, instead of containing static code, they contain an intelligent request to the AI agent. These prompts can help automate code generation, automate repetitive documentation, or guide Copilot through defined workflows in a consistent manner. They bridge the gap between casual, ad-hoc queries to Copilot and systematic, repeatable processes integrated into your team's development pipeline.

• Workspace prompts are available for a specific project or workspace and they're saved in the .github/prompts folder in the root of the workspace.
• User prompts are available to all projects, and are stored in a special file in the VS Code profile.

Structure

Prompt files themselves are nothing more than Markdown files that follow a specific set of conventions:

• Their filenames match the format: name-of-prompt.prompt.md
• They contain a YAML Frontmatter header where you define important metadata, such as the preferred AI mode, model, and required tools:

---
mode: agent
model: GPT-5
tools: ['githubRepo', 'search/codebase']
description: "Implement an API call in the application"
---

Contents

Apart from the header, the contents of prompt files should usually follow the same overall format of a prompt you'd use to make a request for the AI agent on the fly. In consequence, the more context you provide and the more specific your request is, the more effective your prompt will be at achieving the desired outcome. It's a good idea to observe good prompting practices to ensure the best results (here's a great guide from OpenAI about best prompting practices)

Also, keep in mind that if your project is using an instructions file, this will be included in the conversation (see this article previously published in my blog about AI agent instructions).

One thing worth pointing out is that if your project uses an instructions file (ex. .github/instructions.md, claude.md or gemini.md) for guiding the AI throughout development, the contents of that file will be included within the AI’s operating context. This means your prompt files should be designed to align with, or at least not conflict with, the instructions in those files. Conflicting information can weaken Copilot’s responses and lead to results that don’t match expectations.

One way to handle this is by periodically reviewing your active prompts and making sure they still align with evolving instructions. In large or long-running projects, this kind of “prompt hygiene” can be invaluable.

You can also customize your prompt by using input variables to request additional information for your prompt via the chat input field.

You can find more about prompt files by looking at the Visual Studio Code documentation.

Prompt collaboration

Once you’ve built a useful library of prompt files, you may quickly realize that some of them are worth sharing with other members of your team. Sharing prompts allows everyone to benefit from standardized workflows and collective improvements.

A great way to collaborate with prompt building is by pairing a centralized prompt repository with the Promptitude VS Code Extension. Promptitude allows you to synchronize prompts and instructions from a set of known prompt repositories. You can create a repository for your team or organization and have everyone install Promptitude to share prompts between them.

Here's how to get started with Promptitude:

1. Create a directory inside your usual development folder, then create three subdirectories: prompts, instructions, and chatmodes.
2. Place all the prompt files you want to share in the prompts directory, ensuring they follow the structure detailed earlier. Similarly, put shared instruction files in the instructions directory.
3. Initialize a Git repository with git init, commit the files, and push them to your organization’s repository hosting service (e.g., GitHub, GitLab). Take note of the repository URL.
4. Ask your team members to download Promptitude from VS Code (see below). Alternatively you can ask them to download it from the VS Code website for the extension (see the link above).

1. Once installed, open VS Code Settings (click on the cog at the bottom right or press Ctrl+, on Windows/Linux or Cmd+, on Mac) and search for "promptitude" in the search bar.

1. Click on "Add Item" and type in the URL of the repository you took note of in step 3.

2. Finally, click on the "✔️ Prompts" indicator at the bottom right to initiate the sync. Restarting VS Code should also do the trick. If everything went well, you should have new prompts to sync.

3. To test your prompts, you can press / within the Github Copilot chat window and start typing the name of one prompt. You'll notice they will be suggested to you.

1. You can also use Promptitude to take advantage of some noteworthy collections of prompts already existing. A good place to start looking is the awesome-copilot repository, which contains a constantly-growing collection of great prompts and instructions.

Conclusion

Prompt files in VS Code, combined with tools like Promptitude, can transform how developers interact with AI assistants. They enable consistent, repeatable workflows, reduce friction in repetitive tasks, and make knowledge sharing between team members seamless.

By structuring your prompts carefully, aligning them with project instructions, and leveraging both team repositories and community resources, you can dramatically increase the value you get from AI-assisted development. While Promptitude is still evolving, it already unlocks opportunities for collaborative AI usage that can scale from small teams to enterprise projects.

Start with a few prompts for critical workflows in your project. Share them with your team. Iterate and improve. Before long, you’ll have built a collaborative library of AI capabilities, ready to accelerate development and free up time for the more creative, complex aspects of software engineering.