Spent three minutes hunting for a prompt you wrote last week? That’s not a minor annoyance. That’s compounding friction hitting you every single session.
Think about how many times a day this actually happens. You write a solid prompt for refactoring a function, it works beautifully, and then it disappears into some notes app you’ll never open again. Next week you need the same thing. You either rewrite it from scratch, wasting ten minutes, or you spend five minutes searching through three different tools hoping you bookmarked it somewhere. Multiply that by every prompt you’ve ever written and the wasted time is genuinely embarrassing to calculate.
Most AI-heavy developers just accept this as the cost of working with LLMs. It doesn’t have to be.
A VS Code extension called Lumra landed recently, and it’s solving something most AI-heavy developers just accept as normal.
What’s new: it stores and organizes your prompts directly inside VS Code. No tab switching, no notes app, no “where did I put that context” spiral. Everything lives in the editor where you’re already working.
That last part matters more than it sounds. Context switching is where focus dies. The second you leave VS Code to find a prompt, you’ve broken your flow. You open the notes app, your eye catches something else, you make a mental note, you come back to VS Code slightly less sharp than when you left. It’s a small thing that adds up across an eight-hour session in a way you don’t notice until you zoom out. Lumra keeps you in the editor. One less reason to break state.
The organization piece is also underrated. Lumra lets you tag and categorize prompts by task type, so instead of one giant undifferentiated list, you’re browsing a structured library. Need a prompt for writing unit tests? There’s a category for that. Code review? Same. Your past self did the work, your current self just picks it up and uses it.
The twist: it’s not just a prompt clipboard. You can build prompt chains. Break one giant instruction into smaller reusable pieces, snap them together as needed. It also hooks into Copilot for faster, more consistent outputs. You’re basically treating prompts the same way you treat functions: write once, reuse everywhere.
Here’s what that actually looks like in practice. Say you have a standard code review flow. Instead of one massive prompt that covers everything, you break it into pieces: one segment for security checks, one for performance patterns, one for readability. Each piece is tight and focused. When you need a full review, you chain all three. When you only need a quick security pass, you grab just that segment. The same raw material covers ten different use cases without you writing anything new.
The Copilot integration takes this further. When your prompts are consistent and stored in one place, your Copilot outputs stop varying wildly from session to session. You’re feeding it the same well-crafted context every time. That consistency compounds. Your AI outputs get better not because the model got better, but because your inputs got cleaner.
How to get started:
- 🔌 Install the Lumra extension from VS Code Marketplace, takes under a minute
- 📁 Build a small library organized by task type (generate, review, refactor, debug), four categories covers 90% of daily use
- 🔗 Take your 3 most-used prompts and split them into reusable chain segments, even just two parts each is enough to feel the difference
- ⚡ Start reaching for the library before writing a new prompt from scratch, that habit shift is the whole game
Pro tip: Don’t migrate everything at once. Three prompts. Build the muscle memory. The rest follows naturally once you feel the difference.
And when you’re building those first three, be specific about when each prompt gets used. Not just “refactor prompt” but “refactor for readability before PR review” or “refactor for performance in hot paths.” The more precise the label, the faster you grab the right one under pressure. Vague categories create the same hunting problem you’re trying to solve. Specific categories make the library feel like a superpower.
One more thing: review and prune the library every two weeks. Prompts go stale as your workflow evolves. A prompt you wrote for GPT-4 might not be the right shape for your current stack. Keep the library lean. Twenty sharp prompts beat two hundred mediocre ones you’ll never touch.
The sticky-notes era of prompt management is over. Your editor can handle this now. 🚀
Keeping prompts organized inside VS Code actually helps a lot
by u/t0rnad-0 in PromptEngineering