Getting Started with AIME Directory Collections in 5 Minutes

In my previous post, I introduced AIME Directory and explained why I built it. Now let’s get practical. I’ll walk you through exactly how to use the collection feature to set up your AI development environment in minutes.

This isn’t theoretical. By the end of this guide, you’ll have a working setup ready to drop into your next project.

The 5-Minute Setup

Here’s what we’re going to do:

Browse the directory and find what you need
Build your personal collection
Export everything as a ready-to-use project structure
Install it in your project
Start coding with enhanced AI assistance

Ready? Let’s go.

Step 1: Find What You Need

Head to aime.directory. You’ll land on the homepage showing recent additions across all categories. But let’s be more targeted.

Scenario: You’re starting a new TypeScript project and want to set up GitHub Copilot properly, add some useful MCP servers, and grab a few handy prompts.

Click on “MCPs” in the navigation. You’ll see over 800 Model Context Protocol servers. That’s a lot. Use the search bar at the top and type “github” to filter. You’ll see several options:

GitHub MCP: Gives Claude access to your GitHub repositories
Git MCP: Local git operations
GitLab MCP: For GitLab users

Click on GitHub MCP to see the details. You’ll find:

A description of what it does
Installation command
Configuration example
Tags for easy discovery

See that “Add to Collection” button? Click it. Notice the collection icon in the header now shows “1” - you’ve added your first item.

Want to try a few more? Search for “sqlite” and add the SQLite MCP. Search for “memory” and add the Memory MCP (it gives Claude a persistent memory across conversations - super useful). That’s three MCPs in your collection.

Step 2: Add Instructions and Prompts

Now click “Instructions” in the navigation. These are framework-specific guidelines that teach GitHub Copilot how to work with your tech stack.

Search for “typescript” and open the TypeScript Best Practices instruction. This file includes:

Modern TypeScript patterns
Type safety guidelines
Common gotchas to avoid
Project structure recommendations

Add it to your collection. Do the same for Node.js Development Standards if you’re building a backend.

Next, head to “Prompts”. Search for “code review” and add the Code Review Assistant prompt. This one’s a time-saver when you need to review pull requests.

Step 3: Configure Your IDE

Click on “VSCode Configs” and browse the available presets. The Copilot Essentials config is featured for a reason - it’s a solid baseline that enables the most useful Copilot features without overwhelming you.

Add it to your collection. If you want to experiment with GitHub Copilot’s agent mode, also add Copilot Agent Mode Pro. The export will merge these configs intelligently, with later additions overriding earlier ones where there’s overlap.

Step 4: Review and Export

Click the collection icon in the header (it should show several items now). You’ll see your Collection page with everything organized by type:

MCPs: Your three server configurations
Instructions: TypeScript and Node.js guidelines
Prompts: Code review assistant
VSCode Configs: Copilot settings

This is your chance to review. Made a mistake? Click the remove button on any item. Want to clear everything and start over? Use the “Clear All” button.

Happy with your collection? Click “Export ZIP”.

Your browser will download aime-collection-2025-10-08.zip. Let’s see what’s inside.

Step 5: Understanding the Export

Extract the ZIP file and you’ll find this structure:

aime-collection-2025-10-08/
├── .vscode/
│   ├── mcp.json
│   └── settings.json
├── .github/
│   └── instructions/
│       ├── typescript-best-practices.instructions.md
│       └── nodejs-development-standards.instructions.md
└── prompts/
    └── code-review-assistant.md

Let’s break down each part:

.vscode/mcp.json

This file configures your MCP servers for Claude Desktop or compatible editors:

{
  "// NOTE": "Configure each MCP server according to its documentation",
  "servers": {
    "github": {
      "type": "stdio",
      "command": "npx -y @modelcontextprotocol/server-github",
      "// repo": "https://github.com/modelcontextprotocol/server-github",
      "// website": "https://github.com/modelcontextprotocol/server-github"
    },
    "sqlite": {
      "type": "stdio",
      "command": "npx -y @modelcontextprotocol/server-sqlite",
      "// repo": "https://github.com/modelcontextprotocol/server-sqlite"
    },
    "memory": {
      "type": "stdio",
      "command": "npx -y @modelcontextprotocol/server-memory",
      "// repo": "https://github.com/modelcontextprotocol/server-memory"
    }
  }
}

The configuration is ready to use. The commented lines provide quick reference to documentation without cluttering the actual config.

.vscode/settings.json

Your VSCode settings, merged from all the configs you collected:

{
  "// Merged from": ["Copilot Essentials"],
  "github.copilot.enable": {
    "*": true,
    "markdown": true,
    "plaintext": false
  },
  "github.copilot.editor.enableAutoCompletions": true
  // ... more settings
}

The merge strategy is smart: later configs override earlier ones, but objects are deeply merged rather than replaced. This means you can layer configs without losing individual settings.

.github/instructions/*.instructions.md

GitHub Copilot automatically loads instruction files from this directory. Each file contains framework-specific guidance:

# TypeScript Best Practices

- Always use strict mode
- Prefer interfaces over type aliases for object shapes
- Use const assertions for literal types
- ...

Drop this folder into your repo, commit it, and Copilot immediately understands your project’s conventions.

prompts/*.md

Your saved prompts as markdown files:

# Code Review Assistant

You are a code review expert. Analyze the following code changes for:

1. Potential bugs or edge cases
2. Performance implications
3. Security vulnerabilities
4. Code style and best practices
   ...

Copy these into your AI chat when needed, or integrate them with your IDE if it supports prompt files.

Using Your Export

Now the easy part. Copy the extracted folders into your project:

# In your project directory
cp -r path/to/aime-collection-2025-10-08/.vscode .
cp -r path/to/aime-collection-2025-10-08/.github .
cp -r path/to/aime-collection-2025-10-08/prompts .

Or if you’re starting fresh, just extract the ZIP as your project template and build from there.

Commit these files to your repo:

git add .vscode .github prompts
git commit -m "Add AI development configuration from AIME Directory"

Now your entire team benefits. Anyone who clones the repo gets the same AI setup automatically.

Pro Tips

Start Small: Don’t add 50 MCPs to your first collection. Start with 3-5 that you’ll actually use. You can always create new collections.

Collection Sharing: The collection is stored in your browser’s localStorage. If you want to share it with your team, export it, commit the files, and let them import by using the same structure.

Experiment Freely: The collection is just in your browser until you export. Add things, try them out, remove what doesn’t work. There’s no commitment until you click export.

Read the Documentation: Each item in the directory links to its source repository. If you need advanced configuration for an MCP or want to understand an instruction file better, click through and read the docs.

Update Regularly: The directory is continuously updated with new MCPs and improvements. Check back periodically and update your collection exports.

Common Workflows

Let me share a few workflows I use regularly:

The Quick Start: For a new project, I export a basic collection (essential MCPs + framework instructions + VSCode config). Takes 2 minutes, gets me up and running immediately.

The Experiment: When I want to try new tools, I create a collection just for experimentation. Add several similar MCPs, export to a test project, and see which one fits best.

The Team Template: I maintain a shared collection for my team’s standard setup. When someone joins, they get the export and they’re immediately aligned with our tooling.

The Learning Path: For learning a new framework, I collect all relevant instructions and prompts. It’s like having a curated knowledge base that I can export and reference anytime.

What If I Make a Mistake?

Don’t worry about it. Your collection is in your browser until you export. If you:

Added the wrong item: Click remove on the collection page
Want to start over: Click “Clear All”
Exported too early: Just create a new collection and export again
Need to modify: The exported files are just text files - edit them directly

There’s no database, no account, no permanent storage until you explicitly export. It’s designed to be forgiving.

Next Steps

You now know how to use AIME Directory’s collection feature. You can:

✅ Browse and search for AI development resources
✅ Build a custom collection of tools and configurations
✅ Export everything as a ready-to-use project structure
✅ Install it in your projects in seconds

In my next post, I’ll show you how to contribute to AIME Directory. Found an amazing MCP that’s not listed? Created a useful instruction file for your framework? Want to share a prompt that saves you hours? I’ll walk through the contribution process.

Until then, go build your collection and see how much faster you can get set up on your next project. I think you’ll be surprised.

Happy collecting! 🎯