Make your GTM system impossible to copy.

We build bespoke AI intelligence orchestration systems that accelerate decisions and unlock unique approaches.

Joe Rhew

A lot of people sleep on CLAUDE.md.

It's the single most important file in any Claude Code project, and most people either skip it entirely or overcomplicate it.

In this video, I show the difference between having one and not having one. Same folder, same content, same question - but in one case Claude immediately finds what I need, and in the other it fumbles around guessing.

The reason: Claude Code automatically reads CLAUDE.md at the start of every session. No prompting. It just loads that context before you even ask your first question.

So whatever you put in there - project structure, how you like to work, critical instructions - Claude has it from the start.

A few things worth knowing:

You can nest them. Root-level CLAUDE.md for general context, subfolder CLAUDE.md for specific instructions. Claude reads both, prioritizes the nested one.

You can reference other files. If your context is getting long, break it into separate files and link to them.

Start simple. I've seen people use AI to generate massive CLAUDE.md files on day one and then wonder why things feel off. A few lines is fine. Add more as you learn what actually helps.

If you're using Claude Code without a CLAUDE.md, you're probably repeating yourself way more than you need to.

How do you use CLAUDE.md in your projects?

GTM Intelligence Orchestration | The Workflow Company

We rebuilt our entire outbound system from scratch. Before sharing what it looks like, a short story:

A few months ago I started working with a Series B AI company.

Hot product. 
Huge TAM. 
The kind of company VCs love.

But they had a problem: too many possibilities.

Their product worked for dozens of use cases, across multiple personas, in countless industries. They knew what was working - but they had no idea what they were missing.

What other industries might resonate? What use cases hadn't they explored?

So we started testing. And I immediately hit a wall.

The old way - building lists in Clay, writing copy, launching campaigns - couldn't match the pace we needed.

We weren't trying to run 1-2 campaigns a month.

We wanted to test 10+ hypotheses. Fast.

So we rebuilt everything from scratch:

1. Context Repo
A single source of truth: company narrative, product positioning, personas, campaign angles, offers. All documented. All version-controlled.

2. Micro-List Building
Instead of 5,000-person blasts, we build targeted lists of a few hundred people per hypothesis programmatically. Each list tests specific traits we have theories about.

3. Programmatic Copywriting
We feed the LLM the exact context it needs—campaign brief, persona, offer—pulled directly from the repo. No manual copywriting bottleneck.

4. Cost Optimization
Rapid experimentation = high token volume. So we built prompt caching and batching that saves 60-80% on costs.

5. Audit Trails
Every decision is documented. If we targeted the wrong pain point, then we can simply tweak the campaign brief, rerun. The system learns.

The result:

We now scientifically test outbound hypotheses with full traceability.

We're not guessing. We're not hoping our instincts are right. We're not rerunning a playbook that once worked for a similar company.

We're systematically exploring the space to find what actually works - not just what worked before for someone else.

The difference between a local maximum and a global maximum.

And it's why I believe the future of GTM isn't more SDRs running their own experiments in silos.

It's a centralized system that controls the testing - so you're not leaving hypothesis exploration to chance.

---

If you're in a similar situation as our client - drowning in hypotheses and frustrated with how slow it is to actually test them or if any of this resonates with challenges you're facing - happy to chat, DM me. 

I'm always down to go deeper on how we're thinking about this and how we've set things up.

Every time you use ChatGPT or Claude, you're starting from scratch.

"Here's my company. Here's what we sell. Here are our personas. Here's our competitive positioning."

Copy. Paste. Repeat. For every single conversation.

Claude Code solves this by writing files. Which means you can build a context repository - markdown files that capture everything an AI needs to know about your business.

Company overview. Products. Personas. Messaging. Competitive positioning. Voice and tone.

And it's not a black box memory - you know exactly what files exist and what they say.

Once it's saved, you never repeat yourself again. You just say "read the context files" and Claude is already up to speed.

In this walkthrough, I walk through building one from scratch for Anthropic as an example:

> Spinning up parallel research agents to gather intel
> Synthesizing raw research into structured context files
> Using that context to brainstorm outbound messaging

The whole process took maybe 20 minutes. And now that context is permanent - ready for the next task, and the one after that. 

(Granted this isn't production grade, but it's enough to get started with for most teams.)

This is the compounding advantage of Claude Code. Every piece of context you save makes every future conversation smarter.

If you're tired of being a broken record every time you open a chat window, this one's for you.

For those of you already deep in Claude Code - what do you wish you'd set up on day one?

--

This is the second video in a series I'm doing on Claude Code for Sales & Marketing teams. Link to the first video in the comments.

Git is the single best investment you can make when starting with Claude Code.

I know it sounds like a developer thing.

But - Claude Code modifies files on your machine. Without version control, you're one bad edit away from losing work you can't get back.

With Git + GitHub, you get checkpoints you can always roll back to, cloud backup, and the ability to pick up your work from any machine.

Here's the mental model that made it click for me: think of Git like packing and shipping boxes.

▶ git add = putting items in the box
▶ git commit = sealing it and writing a label
▶ git push = shipping it to the warehouse

The reason you "stage" files before committing is so you can group related changes together. If you update your persona doc and that triggers changes to your campaign angles and pain points, you probably want all of those in the same box. That way you can roll back the whole thing if your hypothesis was wrong.

If you're still confused, that's ok. Watching this video will help clarify things for you.

In this video, I walk through:
→ What Git actually is (and why it's more powerful than Google Docs versioning)
→ The add → commit → push workflow
→ How to pull changes when working across machines

What's holding you back from using Git?

---

This is the fourth video in my Claude Code series for GTM teams. Links to the previous episodes below, along with the full 31-min long YouTube version of this video which includes: 
- setup instructions
- protecting your API keys with .gitignore (!!!)
- using Claude Code to run Git commands for you

---

Previous episodes:
- 001 Setup: https://lnkd.in/gyWz4Fm6
- 002 Company Context: https://lnkd.in/g6M9WzbN
- 003 CLAUDE-dot-md: https://lnkd.in/gRCGjbuq

Full YouTube version: https://lnkd.in/gk_qNW_7

Claude Code isn't just for developers.
                                                              
At The Workflow Company, we've been using it daily for GTM work - research, competitive analysis, content, outreach, internal ops - and it's completely changed how we operate.
                                                              
Most people still think of it as a coding tool. It's not. It's an AI assistant that can actually take action on your computer. Write files. Search the web. Run scripts. Chain tasks together.
                                                              
It's a different dimension compared to chat interfaces.
                                                              
If you're in GTM and haven't tried it yet, I made this video to get you started. It's the first in a series where I'll share how we actually use it - not for coding (although we do a fair bit of it), but for the GTM work you're already doing.
                                                              
Claude Code is the single tool I'd recommend to anyone who wants to push the boundaries of what's possible in GTM right now. Hopefully this helps you get over the line.

What's your take on Claude Code? Would love to hear about your experience with it.

I try not to have regrets but here's a big one from 2025.

We went through a complete website refresh - new branding, new pages - last year. The design was great (Thanks team Odama), and we were really happy with it.

Since we already had a site up on Webflow, inertia took over and I made the decision to develop the new website on Webflow. Looking back, this was clearly the wrong decision.

Webflow and other low-code tools were amazing in the pre-AI era. They abstracted away the technical nuisances for the less technical users. Instead of writing code, you could click and drag your way around and build something semi-presentable.

But with the cost of writing code approaching an asymptote of 0, the cost of these no-/low-code abstractions is inversely approaching ∞. 

Why should a user need to learn the idiosyncrasies of a platform that is detached from code, when they can simply ask an LLM to create a coded solution?

The cost of this decision often appears in maintenance and iteration speed.

For us, practically speaking, developing our site on Webflow means...
- it takes longer for us to make tweaks to it
- it takes longer to experiment / iterate - spin up new pages, run A/B tests, etc
- it costs more to change anything (hiring a Webflow developer vs. using Claude Code)

The point isn't to specifically call out Webflow, but just use it as an example to illustrate a point that's becoming more and more obvious:

Given LLMs' current capability, the cost of abstraction continues to increase.

And the flip side: the value of code-based skills keeps compounding. 
Code is portable.  
Code is composable.
Code is extensible.
And perhaps most importantly, AI is really good at working with code.
Platform-specific knowledge is none of these things.

So here's the takeaway. If you're evaluating tools in 2026, ask yourself: 

Am I learning a siloed platform's quirks, or building with code that compounds and gives me leverage?

Initial thoughts on Claude Coworker, the Claude Code wrapper for non-technical folks:

> You can give Coworker access to a file directory with files you want to work with, and in the background it loads up a Linux filesystem sandbox with clear isolation from the rest of your system. Good safety/privacy feature without the user having to do anything on their end

> Coworker, as far as I can tell, does not yet have the ability to revert any changes it makes. I can already see a lot of tears shed over Claude accidentally deleting and overwriting files

> Because Coworker has access to your local file system, I see this first iteration being largely single-player. But what makes Claude Code awesome is that you can sync to git, and make it multi-player and collaborative

> Coworker's interface feels more session-based compared to Claude Code's directory-based. Meaning, Coworker would be great for working on a particular issue at the moment, but the work feels more disposable versus compoundable. Claude Code, with its directory-based approach, feels like it brings more permanence to the work you do, allowing you to iterate on the same set of files and build on top of your previous work

> Feels snappier than Claude Code; most likely has to do with the streaming text - Time-To-First-Token

Coworker will still feel immensely powerful for folks who have not started using Claude Code yet. I still believe that the UI layer is collapsing, and that's the case for Coworker as well. The polished interface compared to Claude Code's terminal is less overwhelming, but to someone used to Claude code, the UI still feels like friction.

Overall, I think Coworker could be a great transient entry point for non-technical folks to eventually graduate to Claude Code. The Anthropic team did mention they released this super early to iterate, so I'm keen to see how it evolves and whether it can stand on its own and have as seismic an impact as Claude Code has had.

We've built a GTM context repo (link to a post with more details in the comments), with outbound being the first use case. 

Here's how we're thinking about extending the application of the contexts.

> Horizontal
We've built the repo to store the contexts and do nothing else on purpose. Fully decoupled from the current application of the context = outbound. Because it's self contained and modularized, we can plug in the same repo to other use cases: 
1. content generation
2. qualification
3. enrichments

> Vertical
The repo is driving outreach sequence generation. For each prospect, we have a clear view into the contexts that were pulled, the resulting sequence and the rationale behind it. But it's not been tied yet to the outcome, i.e. response from the prospect or lack thereof. We want to close the loop, so that AI can help with pattern-matching:
1. Contexts are programmatically retrieved and composed
2. An outbound sequence is generated by an LLM based on 1
3. A positive reply to 2 is received
4. LLM analyzes 1, 2, and 3 and generates a hypothesis to test
5. Back to Step 1, the hypothesis from 4 is fed as a context

Personally really excited about step 4 - it essentially unlocks self-learning.

Claude Code literally 10x'd our iteration speed. 

We don't outsource thinking to it - we're still very much in control of the dialogue and the final decision. But it's great at pumping out different brainstorming ideas that we can apply our judgment against.

It really is as easy as feeding it existing context files and asking it to be a brainstorming partner. We talk through the ideas together, agree on the final output, which Claude generates. 

Another piece of context created that we can feed in a future Claude Code session for further refinement and iteration.

What did we do before CC?

Here's my roadmap for automating context repo updates.

(I'll never reach Stage 4 but that's ok.)

---

First - what's a context repo? A central place where you store everything an AI needs to know about your business. Positioning. Personas. Products. Voice.

Load it once, and you stop repeating yourself in every conversation with an LLM.

The most common question I get after people set one up: "How do I keep it updated?"

Because your business evolves. You refine your messaging after a big client win. You sunset a product line. Your ICP shifts.

Meanwhile, your context repo is stuck in the past. And every AI output built on stale context drifts further from reality.

Here's how I think about the progression:

---

1️⃣ Stage 1: I do, AI helps

I drive the updates. AI assists with the drafting.

"Hey Claude, I've changed my thinking on how we position ourselves. Pull up the last few client calls for context, then update the positioning doc. Show me what you changed before saving."

2️⃣ Stage 2: AI surfaces, I decide

AI monitors my raw context sources - call transcripts, LinkedIn posts, Slack threads - and surfaces drift and decay.

"I noticed your last 3 posts emphasize 'context as code' but your messaging doc doesn't mention it. Want me to suggest changes?"

I'm still in full control. But I'm not the one catching drift anymore.

3️⃣ Stage 3: AI does, I approve

AI makes changes autonomously - but staged, not live. It creates a pull request. I review and merge.

Full audit trail. Full veto power.

4️⃣ Stage 4: AI does

AI updates my context repo directly. No review. No approval. Full trust.

I don't think I'll ever get here. And I don't think you should either.

---

Here's why:

Context is the foundation of every AI output you produce. Content. Campaigns. Etc.

Get the context wrong, and everything downstream is wrong.

The goal isn't to remove yourself from the loop, but rather to remove the tedious parts - the monitoring, the drafting, the formatting - while keeping yourself where it matters: the judgment call.

Stage 3 is the sweet spot. You get 90% of the efficiency with 100% of the control.

Stop optimizing for full automation, and instead optimize for the right level of human oversight.

---

Where are you on this spectrum? Most are between 0 and 1.

What are the building blocks of a great cold outreach message?

I have been building a system to programmatically pull together contexts to generate an outreach sequence. Here are all the types of contexts that go into it:

-------------
Our contexts
-------------
1. Company
> Context about the company, its origin, mission, founders, funding history, etc.

2. Narrative
> The narrative - why now, why us - around the company and the product. More macro than messaging

3. Messaging
> Key messaging pillars, tone of voice, specific phrases to use/avoid

4. Product
> Product overview, both technical details and a JTBD framing

5. Channel Best Practices
> Email / LinkedIn / etc. - unwritten rules around best practices, accepted norms

6. Personas
> Various ICP personas that the company has a hypothesis on. Includes pain points, aspirations, JTBD, buying triggers, owned KPIs, etc. Only the relevant personas get pulled into the final composed context

7. Campaigns
> Campaign angles that specifically go deeper on all of the contexts above - for a specific persona in a specific industry, what product features and pain points do we highlight, what should our messaging tone be, etc. Only one campaign brief gets pulled in

8. Offers
> Different offers we can make in a cold outreach context. Should we ask for a meeting, can we send them resources, could we ask for permission to send them a personalized lead magnet? Offers we want to test get pulled in

--------------------
Prospect's contexts
--------------------
1. Account research
> Deep web-based research; disambiguation is tricky, and verifying all the facts are about the target company is most of the work

2. Contact professional experience
> Mostly based on LinkedIn data. What's their current role, career trajectory, what words do they use to describe themselves?

3. Contact social media presence
> Mostly LinkedIn - works great for active posters/engagers; not so much for lurkers

---

This feels fairly comprehensive to me, but I'm sure there are other considerations that I'm overlooking. So what else should be in this list of contexts?

One thing I think about a lot these days is the durability of our ideas, products, and services.

When ChatGPT 3.5 came out (Nov 2022, only just over 3 years ago) - all of us had this collective expansion of ideas and possibilities. With the help of LLMs, any idea seemed feasible.

Today, working inside of multiple Claude Code terminals for most of the day, every idea feels ephemeral. Most of us are probably feeling some version of this tension - as companies opt to build versus buy, and mature and seemingly resilient businesses go out of business overnight.

What is durable in this age of disposable software?

I've been sitting with this question, and here's where my thinking is landing:

Coding agents compress build time. What took weeks now takes hours. But they don't compress the human elements - trust, relationships, community, domain expertise. These still compound at a human pace.

The tempting advice is "just stay in the game long enough." But I don't think that's the answer - at least not for pure software businesses. If the moat is just code, someone can rebuild it tomorrow.

What seems more durable: businesses where human elements are architecturally intertwined with the software. 

Some examples:

► Marketplaces, where network effects are built on human trust - supply and demand that took years to cultivate. Can't clone that overnight.
► Forward-deployed engineering, where humans are embedded in the value prop itself.
► Service-as-a-software = human expertise + judgment + taste + software

Maybe that's why we're seeing the rise of services-enabled software, forward-deployed engineering as a discipline, and a rethinking of the "pure SaaS" playbook.

I'm still working through this, but I think the question isn't just "what should I build?" It's: how deeply are human elements woven into the business itself?

Curious to get folks' take on this. What feels durable to you right now?

Same workflow. Different clients. Different fit assessments.

We built a person research workflow that passes a client_id into every enrichment request.

client_id=wfco → pulls The Workflow Company context.
client_id=client_a → pulls Client A context.

The research agent sees the same person's LinkedIn activity. But evaluates fit against different criteria.

A technical founder posting about developer tools might be:
→ High fit for our dev tool client
→ Low fit for our enterprise sales client

One enrichment pipeline. Infinite context variations.

Why did we separate this out instead of hard coding our context?

Imagine I have multiple clients. I can pass in their IDs and look at the same person through different lenses. Someone who's not a good fit for The Workflow Company might be a great fit for a client of ours.

Building this composability into your workflows means you don't have to repeat yourself. You don't have to build separate enrichment workflows per client with the same logic duplicated everywhere.

Update one prompt, forget to update the others? Not a problem when the enrichment logic lives once and the context is the variable.

The context about your business should live in a programmatically accessible source. Your enrichment modules just point to it and pull whatever the latest version is.

p.s. the context database is doing a lot of the heavy lifting here - how it's structured, how data is stored, updated, and retrieved. Get that right and this architecture is easy to set up and maintain

My good friend Matteo Tittarelli ⚡️and Jared Waxman are back with the third cohort of GTM Engineer School. 

"GTM engineering" as a discipline is nascent and evolving quickly. If you've been on the fence and unsure of where to start, this course would provide a great starting point to ground yourself and understand the landscape of frameworks and tools - after which you can go on your own and start exploring areas that interest you. 

You'll be learning from some of the most forward thinking operators in the space, how they think about problems and how they use their favourite tools to solve them.

DM me if you're interested in taking the course - I've asked Matteo and Jared to tack on my affiliate fee as an additional discount.

Mike Williams

Founder of Everything Marketplaces

Founder of Everything Marketplaces. I'm always working with, helping, & investing in marketplace startups. I've previously started a few marketplaces (two acquired). I also recently wrote bit.ly/marketplacesguide

You learn more about me at the following:

www.iammikewilliams.com
angel.co/yoroomie
twitter.com/yoroomie

Startup Advisor

There's nothing like hearing about our Everything Marketplaces meetups and how much founders & teams enjoy connecting at them. 

A big thanks to some of our community leaders like Abby Nawrocki for helping organize them and our Chicago meetup that we had Wednesday. 

It looks like there's a good marketplace scene in Chicago!

taplio

The Battle

Joe Rhew

Mike Williams

Followers

Posts

Engagements

Likes

Performance ScoreJoe Rhew's LinkedIn Performance

Performance ScoreMike Williams's LinkedIn Performance

Ready to grow your LinkedIn presence?

taplio

The Battle

Joe Rhew

Mike Williams

Followers

Posts

Engagements

Likes

Performance Score.css-goub6s{font-size:var(--chakra-fontSizes-md);font-weight:500;color:var(--chakra-colors-gray-600);display:block;margin-top:var(--chakra-space-1);}Joe Rhew's LinkedIn Performance

Performance ScoreMike Williams's LinkedIn Performance

Ready to grow your LinkedIn presence?

Performance ScoreJoe Rhew's LinkedIn Performance