Managing Prompts Where You Already Work - New Vscode Extension

I’ve been trying to clean up how I manage prompts lately, and kept running into the same issue: everything was scattered.

Some prompts in notes, some in chat history, some half-working versions buried in random docs. It worked… until it didn’t.

That’s what led me to Lumra — especially the idea of handling prompts directly inside VS Code instead of treating them like temporary inputs.

The Friction Nobody Talks About

Once you move beyond basic usage, prompts start to pile up:

• Slight variations of the same prompt
• Different versions for different contexts
• Chains written manually and reused inconsistently
• Outputs that are hard to reproduce

At some point, you’re not just “writing prompts” anymore — you’re maintaining them.

But without the kind of structure we’re used to in development.

Why VS Code Actually Makes Sense

Managing prompts inside VS Code sounds obvious in hindsight.

You already have:

• Your project files
• Your actual working context
• Version control
• A structured environment

Bringing prompts into that same space changes how you work with them:

• You can keep prompts close to the code they relate to
• You don’t lose context switching between tools
• You can iterate without starting from scratch every time
• You naturally start organizing things better

It stops feeling like guesswork and starts feeling more like a workflow.

Small Shift, Big Difference: From Single Prompts to Chains

One thing that made a noticeable difference for me was breaking prompts into smaller steps.

Instead of one large prompt, you get something like:

1. Understand the input
2. Extract what matters
3. Decide what to do
4. Generate the output

Each step becomes easier to tweak.

And more importantly, easier to reuse.

Doing this inside VS Code makes it even more practical — you can actually manage these chains instead of rewriting them every time.

What You Gain From This Setup

Working this way leads to a few clear benefits:

Less repetition

You stop rewriting the same prompts over and over

More consistency

Same structure → more predictable outputs

Easier iteration

You can adjust one part without touching everything

Better organization

Prompts live alongside your actual work

Reusability

Good prompts turn into building blocks, not one-offs

None of this is groundbreaking individually — but together, it removes a lot of friction.

Closing Thoughts

This isn’t about using more tools — it’s about using the right place for something that’s already part of your workflow.

Managing prompts inside VS Code just fits better once things get even slightly complex.

That’s also why I found Lumra interesting — especially its VS Code extension approach. It treats prompts less like temporary inputs and more like something you can actually organize, reuse, and build on over time.

It’s a small shift, but it makes the whole process feel a lot more controlled.