Aligning AI Threads with Your Codebase using the Prompt and Tag method

As AI continues to weave itself tighter into my daily workflow, I find myself spending more time experimenting with ways to make it more seamless - I want to decrease the time spent fiddling around with AI tools, while maximizing their value-add - a value which still seems to be limitless as far as I can tell. If you're serious about making AI a daily tool, you're likely using a variety of tools, each with their own strengths and weaknesses. An issue that creeps up more often than not is managing your threads. Not only is it hard to remember which platform your conversation was in, but the context in each of your conversations has changed - whether due to code changes, or document updates. I've stumbled upon a technique that has been working so well, that I decided to tell everyone about it. I call it "Prompt and Tag," and it's transforming how I manage context between AI tools and my codebase.

The Challenge: Keeping AI Threads in Sync with Code

If you've been working with Large Language Models (LLMs) like I have, you've probably encountered this scenario: You're deep in a conversation with Claude or ChatGPT about a feature you're developing. You've made changes to your code, but now your AI thread is out of sync. How do you keep everything cohesive, especially when you're actively developing and switching between multiple AI tools?

Enter Prompt and Tag

Prompt and Tag is a workflow I've been iterating on that allows me to effortlessly switch between AI tools while ensuring cohesion between their context windows and maintaining memory parity. Here's how it works:

1. Create a Snapshot: I use a make target called prompt-and-tag that automates the process of creating a versioned snapshot of my codebase.

2. Generate a Unique Tag: The system creates a unique tag name using the current date and time (e.g., llm-snapshot-YYYYMMDD-HHMMSS).

3. Convert Code to Text: Using a tool called code2prompt, the current state of the codebase is converted into a text format.

4. Push and Save: The tag is created in the Git repository and pushed to the remote. The converted codebase is saved to a temporary file, but I typically never look at it again.

5. Ready for AI: The formatted tag name is provided, which I can use to label the content version in my AI discussions.

Why It's a Game Changer

No longer do I have to remember at what state my project was in when this AI conversation took place. I have a formal way to associate the conversation with a snapshot in time of state of my code base without affecting my commit cadency or the git log.

Another benefit is ensuring all AI parties involved are at context-window parity. When I'm talking to Claude and want a second opinion from Perplexity, I can synchronize their context windows in a consistent and frictionless way.

All experienced developers are aware of the benefits of good observability. As AI digs its way deeper into our development lifecycle, I foresee a new need for observability into the AI contexts that play a part in shaping our code. This includes research into technical trade offs, design decisions, requirement negotiation, and more. It will become increasingly important to be able to map a prompt outcome to a specific state of the codebase to gain more insight into the process that was followed by the developer that minted the query.

Integrating Prompt and Tag into Your Workflow

Implementing this technique is easy, but to make it even easier, I've created a repo you can use to bootstrap your existing projects as non-invasively as possible.

Prompt and Tag, by @delorenj

The beauty of this approach is its simplicity and effectiveness. It reduces the cognitive load of managing multiple contexts and ensures that my AI-assisted development process remains smooth and coherent.

## Looking Ahead

As we continue to integrate AI tools into our development workflows, techniques like Prompt and Tag will become increasingly valuable. They allow us to harness the power of AI assistants while maintaining the rigor and version control that's crucial in software development.

I'm excited to see how others in the community might adapt and improve upon this technique. Have you developed any similar workflows for managing AI-assisted development? I'd love to hear your thoughts and experiences in the comments below!

Remember, in this rapidly evolving field, it's all about experimentation and finding what works best for you and your team. Happy coding, and may your AI threads always be in sync with your code!