Adding Prompts to VS Code - How I Learned to Stop Worrying and Love AI Context

Right, let's have a chat about something that's been driving me absolutely mental: watching developers fumble about with AI prompts like they're trying to communicate with aliens using interpretive dance.

You know the drill. You fire up GitHub Copilot or Claude in VS Code, type "make this better" and then wonder why the AI responds with the digital equivalent of a confused shrug. It's like asking your GPS for "somewhere nice" and then acting surprised when it takes you to a Walmart parking lot.

The Problem: We're All Winging It

Here's the thing that nobody wants to admit: most of us are absolutely rubbish at prompting AI tools. We treat them like magic boxes that should somehow divine our intentions from the most vague possible instructions.

I've watched brilliant developers - people who can architect distributed systems in their sleep - completely lose their minds when it comes to writing a decent prompt. They'll spend ages crafting the perfect UI interface but then ask an AI to "fix my code" without any context whatsoever.

The result? You get back suggestions that are about as useful as a you'd expect from someone that as never seen your codebase.. The AI doesn't know your codebase, your conventions, or what you're actually trying to achieve. It's like hiring a consultant and then refusing to tell them what your company does.

And here's the kicker: everyone knows this is a problem, but we keep doing it anyway. Because admitting that you need to learn how to talk to a computer feels a bit embarrassing, doesn't it?

Why This Keeps Happening

The root cause is simple: we've been conditioned to think that AI should "just work" without any effort on our part. The marketing departments have done such a good job convincing us that these tools are magical that we've forgotten they're just very sophisticated autocomplete systems.

AI tools are brilliant, but they're not mind readers. They need context, structure, and clear instructions - just like any other tool in your development arsenal. You wouldn't use a database without understanding SQL, so why would you use AI without understanding how to prompt it properly?

The other issue is that most developers treat prompting as an afterthought. We spend hours setting up our development environment, configuring our editor, and organizing our code, but we can't be bothered to spend five minutes setting up proper prompts.

It's the equivalent of using a Ferrari as a shopping trolley - technically it works, but you're missing out on most of the benefits.

How to Actually Fix This

Alright, enough moaning. Let's talk solutions. The good news is that VS Code has some absolutely brilliant features for prompt engineering that most people completely ignore.

1. Create Prompt Files

First things first: stop typing the same context over and over again. Create dedicated prompt files in your project:

// .vscode/prompts/code-review.md
You are reviewing TypeScript code for a NuxtJS application.

Context:
- This is a personal blog built with Nuxt 3 and NuxtUI Pro
- We use TypeScript with strict mode enabled
- Code style: camelCase variables, PascalCase components, single quotes
- We prefer composition API and async/await

When reviewing code, focus on:
1. Type safety and proper TypeScript usage
2. Performance implications
3. Accessibility concerns
4. Code readability and maintainability

Current file context: [PASTE FILE CONTENT HERE]

Please review this code and suggest improvements.

2. Use VS Code's Built-in Prompt Features

VS Code has some amazing features that most people never discover:

Workspace Instructions: Create a .vscode/copilot-instructions.md file (which you probably already have if you're reading this blog). This gives Copilot context about your entire project without you having to repeat yourself constantly.

Custom Commands: Set up custom commands in your settings for common prompting tasks:

{
    "github.copilot.chat.welcomeMessage": "never",
    "github.copilot.editor.enableAutoCompletions": true,
    "github.copilot.chat.localeOverride": "en"
}

3. Structure Your Prompts Like Code

Treat your prompts like any other code - they should be maintainable, reusable, and well-organized. Create a prompt library:

.vscode/
├── prompts/
│   ├── code-review.md
│   ├── bug-fix.md
│   ├── refactor.md
│   ├── test-generation.md
│   └── documentation.md

Each prompt should have a clear purpose and consistent structure. Think of them as functions - they should do one thing well.

4. Use Progressive Context Building

Instead of dumping everything into one massive prompt, build context progressively:

1. Start with the high-level context (project type, tech stack)
2. Add specific context (current file, related files)
3. State your specific request clearly
4. Provide examples of what good output looks like

5. Leverage VS Code Extensions

There are some brilliant extensions that make prompt engineering much easier:

• Prompt Engineering Helper: Provides templates and snippets for common prompts
• AI Prompt Manager: Lets you save and organize your favorite prompts
• Context Manager: Helps you include relevant file context automatically

The Bottom Line

Look, I get it. Setting up proper prompts feels like extra work when you just want to get stuff done. But here's the thing: spending a bit of time upfront to create good prompts will save you hours of frustration later.

Think of it like setting up your linting rules or configuring your build system - it's a one-time investment that pays dividends every single day.

And honestly? Once you start using AI tools properly, with good context and clear instructions, it's genuinely transformative. You'll wonder how you ever managed without them.

Just please, for the love of all that's holy, stop asking AI to "make this better" without any context. Your future self (and your colleagues) will thank you.

Now stop reading blog posts and go set up some proper prompts. Your productivity will thank you, and you might even enjoy working with AI tools instead of fighting them.