S01E22: The Codebase Was Always Bigger Than You.

Let's begin

Five weeks ago you had an AI with no memory. Today you have something most reps will never build.

A Main Branch that tells your AI who your buyer is, what your product does, how to handle every objection your team has heard, what your process looks like, and how your team sounds.
A Personal Branch that carries your account history, your voice, your deals, your read on your market.
A Prompt Library that turns all of that context into repeatable, improving action.

Three layers. Sixteen files. Built in five weeks.

There's one more thing. Everything you built is invisible to everyone else on your team. The objection handle that works in your segment? Locked in your personal branch. The cold opener format that gets replies? Same. The prompt you've run 50 times and send without editing? Nobody else can load it. Meanwhile, the Main Branch your team is running from is still the same version it was when you started. Every rep is making mistakes you already figured out. Every new hire is going to spend 60 days reinventing things you discovered in week two.

The merge is the last step. Not because the system isn't complete without it. It is. You've already built something that makes you better. The merge is what makes the team better.

What Goes Back and What Stays

Not everything earns a spot in the team layer. Most of what you built is personal and should stay that way. Your account history, your deal context, your specific relationship intelligence: that's yours. But three things bubble up.

The first is objection handles. If you've used the same handle ten or more times and it works reliably in your segment, it belongs in the team's objections.md. Not because it's clever. Because someone who joins next quarter is going to face that same objection in their first week and currently has nothing to work with.

The second is voice examples. If you wrote an opener this quarter that got a meaningful reply rate, that example belongs in the team's voice.md. You strip the account-specific details and the pattern stays. That's what gives the next rep a real example to learn from instead of a description of what good looks like.

The third is prompts. If a prompt in your library has hit fifty runs and you send the output without editing, that structure is too valuable to keep to yourself. Strip the personal context load, make it generic, propose it as a team prompt. A new rep runs it on day one and gets output at the level it took you fifty iterations to reach.

The Merge Protocol

This is not a weekly practice. It's quarterly. Most of your personal branch stays personal, and that's right. Four steps: review what you've built, flag the candidates, run the filter, propose the addition.

The filter is one question: would this help a new rep on their first call into my segment? That's it. If yes, propose it. If no, keep it. You don't need a rubric or a scoring system. You need to be honest about what's genuinely useful versus what's specific to your situation. The proposal is one message to whoever owns your Main Branch. Here's what worked. Here's why it belongs in the shared layer. Let them decide if it fits. Your job is to surface what you learned, not to maintain the Main Branch yourself.

What the Team Gets

Without this practice, your Main Branch is a snapshot. It reflects what your team knew when someone first sat down to build it, and it doesn't update unless someone explicitly decides to update it, which usually means it doesn't. With this practice, your Main Branch is a living system. Every rep's best quarterly discovery has a path into the shared layer. The rep who joins six months from now loads a Main Branch that has two quarters of real-world improvements baked in. They start where your best rep today finished.

That's the compounding, and it runs both directions. When the Main Branch improves, your next Personal Branch build gets better faster. You're not starting from a frozen baseline. You're starting from the current state of the team's collective knowledge, and your personal layer builds on top of something that already moved.

The Complete System

Let's close the loop.

E17: your AI had no memory. You had great notes and no way to give them to the tool. E18: you learned the architecture. Two layers, shared and personal. A place to put everything.
E19: you built the Main Branch. Five files, specific enough to be useful, built in an afternoon.
E20: you built the Personal Branch. Four files only you could build. Account history, your voice, your deals, your market read.
E21: you built the Prompt Library. Prompts that load your context, specify the output, define what done looks like, and get better every time you run them.
E22: the merge. The quarterly practice that keeps the Main Branch alive and turns individual wins into team infrastructure.

That's the system. Not a product. Not a platform. A set of files you own and a set of practices that keep them useful. Most reps won't build this. They'll keep opening new chats from scratch, losing the prompt that worked, starting where they started. The rep who builds this starts every week further ahead than the week before. The team that builds this starts every quarter further ahead than the quarter before.

What the Quarterly Review Looks Like

Five checks. One quarter. Thirty minutes. Review your objections work, your voice examples, your territory observations, your prompt library. On each one, ask the same question: would this help a new rep on their first call into my segment? Most items won't pass, and that's right. You're not trying to push everything into the team layer. You're looking for the one or two things that genuinely belong there. The merge is a filter, not a fire hose.

When something passes, write a one-paragraph proposal and send it to whoever owns the Main Branch. That's the whole practice.

Rep Action this week

You're done building. Now run the system. Open a new chat. Load your full codebase: main-branch/ files, personal-branch/ files, and the two prompts you built last week. Use pre-call-prep.md on your next account call. Note what you'd change. Update the prompt. Load it. Run it. Update what needs updating. The system compounds from here.

10x the context. Half the time.

Image from: S01E22: The Codebase Was Always Bigger Than You.

Speak your prompts into ChatGPT or Claude and get detailed, paste-ready input that actually gives you useful output. Wispr Flow captures what you'd cut when typing. Free on Mac, Windows, and iPhone.

Try Wispr Flow free