You ask ChatGPT to draft a launch email. You give it three sentences of instruction. Back comes a few paragraphs about how the platform “revolutionizes” the workflow, under a subject line that would work for any company in your category.
So you rewrite the prompt. Feed it more files that seem relevant. Maybe try a different model. But nothing works. You end up doing most of the work yourself.
In the meantime, everyone online is talking about complex agentic workflows and GTM operating systems and you start wondering whether you need to hire a developer to fix this.
But the prompt is not the bottleneck. The input is.
The model isn’t producing clichés because it’s dumb. It’s producing clichés because that email is the only thing it can write with what you gave it. It doesn’t know how your product gets implemented, which objections stall your deals, or which claims your legal team already struck. So it fills the gap with the average of everything it has ever read about B2B software. That average sounds exactly like the draft you got.
There’s a name for what’s missing, and a kitchen practice that explains it better than any diagram I’ve seen.
→Mise en place, for marketing
Mise en place (pronounced MEEZ-ahn-PLAHSS) is the practice of gathering, prepping, and arranging every ingredient before the first pan hits the heat. Restaurants that skip it don’t fail at the cooking step. They fail thirty seconds into service, when the line cook reaches for the shallots and there are no shallots.
The tools are fine. Most marketing teams are running AI without a prep station.
That prep work breaks into four layers, and they stack. Knowing which layer you’re standing on tells you what to fix.
→Layer 1: the context (your ingredients)
Context is everything the AI would need to know to write like someone who works at your company. These are the ingredients, and they fall into two categories: live context and stable context.
Live context comes from data sources like your CRM, call transcripts, ad platforms, product analytics. It changes daily, and it reaches the AI through a connection someone sets up once. Usually that’s a connector in the tool’s own settings, an API, or an MCP (Model Context Protocol) server. Think of it like a universal plug that connects your AI tools directly to live systems like your CRM without needing custom developer code for every single app.
Live data makes some really cool use cases possible. On the Breaking Through in Cybersecurity Marketing podcast, Tom Wentworth, CMO at incident.io, described feeding transcripts from sales discovery calls into an AI that drafted and published blog posts answering the exact pain points and questions raised on those calls, so sales could share the article as a near-instant follow-up.
But use cases like these are only possible with stable context: what your product does and how it’s implemented, who buys it and who blocks the deal, which claims are safe and which need a qualifier, what a competitor genuinely does better. In Tom’s case, that was their product pages, a practical hands-on guide for incident management put together by the co-founder, and guidelines for blog articles.
Here’s the thing. Most complex B2B companies don’t have that stable context written down anywhere an AI tool can actually use. Maybe because they don’t have a dedicated PMM to own it. Maybe the files exist, but they’re scattered across drives, decks, and PDFs that hardly get opened. More often though, the deepest technical knowledge mostly lives in two or three experts’ heads, and everyone routes through them.
If this is you, documenting stable context is step one. Your AI can’t cook with an ingredient nobody put in the pantry.
For a B2B SaaS company, a stable context layer might look something like this:
Your structure might look different, and that’s fine. What’s most important is:
- Each piece of knowledge has one home, so the same fact isn't spread across three files.
- Nothing in the files is aspirational. It's what's true now, not what you wish were true.
- Everything is current and dated, so a person or an AI can tell what still holds.
→Layer 2: context management (the pantry)
Once the ingredients exist, someone has to stock the pantry and keep it organized.
If the expired ingredient is in the pantry, the chef will cook with it. Your 2024 pricing sheet is still in the shared drive. Your AI writes a battlecard citing a competitor gap that closed eight months ago. Sales sends it. The prospect corrects them on the call. The chef has no way to know it’s expired.
The good news is that keeping a pantry current is manageable when the structure is already there. These five things matter most:
- Pick one home for the files. A shared drive folder in Google Drive, SharePoint, or Dropbox is enough for most teams. A wiki like Confluence or Notion works if that's already where people look things up. What matters is that there's one place, and everyone knows it.
- Name an owner. One person responsible for making the updates and telling the team they happened. Your PMM if you have one. Otherwise the marketing lead, or whoever runs enablement. Shared ownership means nobody does it.
- Update on triggers, review on a schedule. Update when something real changes: a release ships, a proof point clears legal, a new objection shows up in three deals a week. Then skim the whole set once or twice a year to catch what the triggers missed.
- Keep a change log. One running file next to the folder. Six fields is enough: date, file, section, what changed, source, who approved it.
- Archive old versions. A stale file that nobody deleted is indistinguishable from a current one, to a new hire and to an AI tool.
There isn’t one right way to do this at the moment. And a lot of the conversations online share really technical setups that can seem overwhelming.
My advice, start with something simple that works for your team. Then change or scale as you learn what works.
→Layer 3: context engineering (the prep station)
This is the prep station. A line cook doesn’t dump the whole pantry on the counter and start cooking. They pull the exact ingredients the dish needs, prep them, and lay them out in the order they’ll use them. Context engineering does the same for your AI: selecting, sizing, and ordering the exact context a specific job needs.
This is the layer people skip, because “just upload everything” sounds like it should work. It doesn’t. Language models lose track of material buried in the middle of a very long input, a well-documented behavior. Hand an AI your 200-page product wiki and ask for a nurture email, and it will build something out of whatever happened to catch its attention.
The simplest version of context engineering is writing instructions for a Claude Project, Custom GPT, Gemini Gem, etc. You load the four or five files that matter and write instructions telling the tool which file governs what: voice comes from the voice guide, product facts come from the brief, no results claim ships without the proof log behind it, and anything the files don’t cover gets flagged instead of guessed.
Prep looks different per dish. Say you sell surgical instrument tracking software to hospitals. The AI workspace where your team drafts campaigns holds the product brief, the persona profile, and the claims guardrail. Someone asks for a follow-up email to a sterile processing director after a demo. The project instructions instruct the AI: for a task like this, use these files, in this order, and here’s what a good draft looks like for us. The draft comes back using the language that director actually uses, addressing the objection that kills those deals, and reaching only for claims that cleared review.
You can also engineer the constraints, not just the facts. A persona document should carry an AI instruction block: a short passage written for the tool, telling it how to apply the persona so it lands the same way in every chat. A claims guardrail does the same job in reverse, giving the AI the list of what it can say, what needs a qualifier, and what to avoid. It stops the model from reaching for an impressive number nobody can back up.
One pantry. A different prep tray for every dish.
→Layer 4: skills and agents (the line cooks)
Keeping with the cooking analogy, a skill is a repeatable recipe: the steps, the inputs, and the standard for a finished dish. Take your campaign brief. A skill can turn your latest campaign idea and goals into the same brief format every time, pulling the buyer pain, the message angle, the approved claims, and the voice rules.
Agents are the line cooks running multi-step orders. It takes that brief and drafts the landing page, the nurture emails, and the ad variants, then checks each one against the claims guardrail before a human ever sees it.
Both are only as good as the context they are given. A flawless recipe can’t replace a missing ingredient, and the best line cook can’t rescue a bad recipe.
Failures run bottom-up. So when your AI output is off, look down the stack.
→Start at Layer 1
The advice and use cases I see people getting excited about live in Layer 4. Build agents. Automate the workflow. Chain the tools together.
That advice isn’t wrong, it’s just out of order. You cannot automate what you never documented.
Yet it’s the part most AI advice skips. Documenting stable context is unglamorous, and it’s the one piece no tool can do for you. It isn’t sitting in a system waiting to be connected. It’s where it was back in Layer 1: buried in old files and in a couple of experts’ heads.
So start there. Pick your highest-value product. Get the experts in a (virtual) room. Interview them to capture what they know about the product, the buyers, and the claims. Transcribe the discussion and use it to create documentation your team can read and your AI tools can use.
Then connect the live data sources or build the agents.
When you start with the foundation, everything above that layer gets easier.
If you don’t have the time, or you know it needs to happen but you’re not sure where to start, consider hiring someone who produces product and buyer context as a service.
AI Context Kit™ is a done-for-you AI source of truth for complex B2B: I run a structured expert interview, fold in the materials you already have, and package it into product and buyer context as polished documents plus AI-ready markdown. Done for you in 2–3 weeks, with minimal lift from your team.
