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.

AI + UX • Raising Pre-Seed for UXpilot.ai • Founder @ UX Design Studio: adamfard.com • SaaS | Fintech | AI

I've designed B2B products for over 10 years

And there are 5 issues I kept seeing:

1 - Unnecessarily complex experiences
2 - Little (or no) user understanding
3 - Bad information architectures
4 - Major usability problems
5 - Lack of consistency

Over and over again.

As a result, companies see:

- Low activation & adoption
- Low retention rates
- High churn rates

Fixing these problems needs a special team and B2B focused methodology

Different from designing for B2C user experiences.

B2B products have:
- Complex workflows
- Multiple user roles
- Intricate decision-making

Here's a simple comparison:
B2C e-commerce: One-click purchase for a single item
B2B inventory system: Multi-step process for bulk orders with approvals

Solution?

I tackled that by building a technical team of product designers and researchers with PhDs.

Our expertise helps you:

- Understand users through research
- Create data-driven concepts
- Design user-friendly interfaces
- Build scalable design systems
- Ensure smooth handoff to developers

Using this approach, we've helped B2B SaaS companies:

- Create MVPs from scratch and raise $5 to $20m in funding
- Scale and improve their complex platforms iteratively
- Increased conversion rate by 400%

To take things further, I'm building an AI product (UX Pilot AI) to streamline the UX process for (our) product- and design teams.

If you want to learn more, go to adamfard.com

Adam Fard

Figma AI is practically dead

In the meantime, with UX Pilot you can generate designs and components directly inside Figma

Unlike other AI tools:
- It's not limited to a few predefined styles
- It's not limited to a few components
- It's not limited to only mobile

Test it for free: https://lnkd.in/dm5NzPDz

Founder of UX Pilot AI (0 → 5mil ARR) | Building New Era of Product Design

200,000+ ‌Figma users are about to move faster than ever ⚡️

For years, you've had to export/import your designs, between UX Pilot AI and Figma

But everything has changed

Now you just have to:
1. Click on “Copy Design”
2. Head to Figma and paste it 

Yes, it’s that simple

Now a couple of clicks is all you need to go from idea to product design 😎

Try UX Pilot for free: https://lnkd.in/ecZ3GyzT

Stop presenting slides —> start showing clickable prototypes 📲

Visualizing your product just got way faster
And a whole lot more interactive too

Here’s all you need to do:
1. Write out the general flow of your app
2. Hit auto-flow to instantly generate prompts for each screen
3. Click “Generate” to build the whole app flow
4. Pick the screens you want to connect
5. And tap “Prototype” to start exploring your own product

No more PowerPoints or clunky presentations
Now you can literally demo your product right inside UX Pilot AI

Start creating your UX/UI designs in seconds
And share your idea clearer and faster than ever

Try UX Pilot for free here: https://lnkd.in/dEfGsTCB

Free trials don’t kill revenue, but bad products do

When we launched UX Pilot AI, we ignored the advice to hide everything behind a paywall

We were generous from day one
People could actually try the product
Use it how they please
Feel the difference

And something interesting happened

They didn’t stay free for long
Most upgraded right away
Others within a few hours

Not because of discounts
Not because of pressure
Because the value was obvious

Today, UX Pilot has grown to 14k paid users on that model

The lesson?
If your product solves a real problem
You don’t need to “convince” people to pay
You just need to let them experience it

Paywalls don’t create value
But products do

And free trials don’t kill revenue
They simply expose the truth

This is how top UX designers are 10x-ing their productivity in 2026

After interviewing hundreds of UX designers we discovered one thing

They don’t start by perfecting screens
They start by generating one wireframe
And then they just iterate from there

With UX Pilot AI, pros use Variations to instantly spin multiple layout options, and Blitz Mode to generate up to 4 wireframe variations in under 15 seconds

Buttons move, layouts shift, and structures evolve instantly

This lets designers see how different decisions change the experience 
Without rebuilding anything from scratch

The result?
> Faster iteration
> More exploration
> Less friction.

In just 2 clicks
You get 4 variations

This is effortless ideation
And this is how wireframing becomes a creative accelerator

Want to win $262 worth of UX Pilot AI credits & pro features? 🙃

The last person to comment on this post
Wins 1 year of UX Pilot Pro, 100% FREE

If you want to speed up your product design process
Here’s how it works:
1. Leave a comment on this post
2. If no one else comments within 24 hours, you’re the winner
3. If someone comments before then, they become the new contender

It really is that simple, looking for the last man/woman standing
If there’s no winner until Feb 27th, the person with the most comments will receive a special prize 👀

PS: If this is your first time hearing about UX Pilot, you can give it a free trial for free.

Just drop a comment and let the games begin!

After analyzing how designers use UX Pilot, one thing became obvious:

The difference between “nice screens” and great UI/UX comes down to how you use the tool.

Here are the 7 UX Pilot AI performance hacks that change everything 👇

𝐇𝐚𝐜𝐤 #1: 𝐒𝐭𝐨𝐩 𝐝𝐫𝐚𝐠𝐠𝐢𝐧𝐠 𝐩𝐢𝐱𝐞𝐥𝐬 𝐢𝐧 𝐅𝐢𝐠𝐦𝐚 𝐚𝐧𝐝 𝐬𝐭𝐚𝐫𝐭 𝐞𝐝𝐢𝐭𝐢𝐧𝐠 𝐬𝐞𝐜𝐭𝐢𝐨𝐧𝐬 𝐢𝐧 𝐔𝐗 𝐏𝐢𝐥𝐨𝐭
Generate a design once. Then use section edits to tweak small parts. Change spacing. Adjust hierarchy. No more pixel dragging, just write down your instructions. This is where UX Pilot gets ridiculously fast.

𝐇𝐚𝐜𝐤 #2: 𝐁𝐞 𝐩𝐫𝐞𝐜𝐢𝐬𝐞… 𝐨𝐫 𝐛𝐞 𝐛𝐫𝐨𝐚𝐝 𝐨𝐧 𝐩𝐮𝐫𝐩𝐨𝐬𝐞
There’s no single “right” prompt. Sometimes you want freedom: “Design a playful onboarding flow for a fintech app”. Sometimes you want control: “Onboarding screen, single column, progress indicator on top, primary CTA at the bottom”. Try both. Each shines in different moments.

𝐇𝐚𝐜𝐤 #3: 𝐔𝐬𝐞 𝐯𝐨𝐜𝐚𝐛𝐮𝐥𝐚𝐫𝐲 𝐚𝐬 𝐚 𝐬𝐤𝐢𝐥𝐥
Upgrade your design language: Clean Minimalist. Modern SaaS. Corporate Modern. Premium Dark Mode. Luxury / High End. Glassmorphism. Digital Brutalism. Illustrative. The more precise your style vocabulary, the better UX Pilot can follow your direction

𝐇𝐚𝐜𝐤 #4: 𝐃𝐞𝐟𝐢𝐧𝐞 𝐜𝐨𝐥𝐨𝐫𝐬 𝐚𝐧𝐝 𝐟𝐨𝐧𝐭𝐬 𝐞𝐚𝐫𝐥𝐲
Want consistency? Set brand colors. Choose fonts. Customize a theme. Upload brand guidelines. Sync UX Pilot with your Figma Design System. Do this once and every generation stays on brand. No more visual roulette.

𝐇𝐚𝐜𝐤 #5: 𝐒𝐭𝐚𝐫𝐭 𝐰𝐢𝐭𝐡 𝐭𝐡𝐞 𝐁𝐥𝐢𝐭𝐳 𝐦𝐨𝐝𝐞𝐥 𝐟𝐨𝐫 𝐟𝐚𝐬𝐭 𝐢𝐭𝐞𝐫𝐚𝐭𝐢𝐨𝐧
Designs generate in around 10 seconds with Blitz Mode. So use that speed. Test multiple prompts. Explore variations. Compare directions side by side. Take the best out of fast exploration.

𝐇𝐚𝐜𝐤 #6: 𝐊𝐧𝐨𝐰 𝐰𝐡𝐞𝐧 𝐭𝐨 𝐠𝐨 𝐝𝐞𝐞𝐩
Quick idea or rough feedback? Turn Deep Design off. Complex flows, dashboards, or systems? Turn Deep Design and Max on. Depth is a lever, so use it intentionally.

𝐇𝐚𝐜𝐤 #7: 𝐎𝐧𝐞 𝐬𝐜𝐫𝐞𝐞𝐧 → 𝐀𝐮𝐭𝐨𝐟𝐥𝐨𝐰 → 𝐚𝐧 𝐞𝐧𝐭𝐢𝐫𝐞 𝐚𝐩𝐩
Nail one screen first. Then click Autoflow. UX Pilot expands that screen into full flows while keeping layout, style, and brand consistent. This is how you scale design without losing coherence.

The truth? UX Pilot doesn’t replace designers. 

It rewards the ones who think in systems, intent, and direction.

Which hack are you stealing first? 👀

In a platform where most brag about success, it is good to remember:

The first Sam Altman project was Loopt. Not OpenAI.
The first Mark Zuckerberg project was ZuckNet. Not Facebook.
The first Steve Jobs project with Woz was the Blue Box. Not the Macintosh.
The first Elon Musk company was Zip2. Not Tesla.
The first Reed Hastings company was Pure Software. Not Netflix.
The first Marc Andreessen project was Mosaic. Not Netscape.
The first Evan Williams product was Blogger at Pyra Labs. Not Twitter.
The first Stewart Butterfield world was Game Neverending. Not Slack.
The first Daniel Ek company was Advertigo. Not Spotify.
The first Kevin Systrom app was Burbn. Not Instagram.
The first Reid Hoffman company was SocialNet. Not LinkedIn.
The first Patrick Collison company was Auctomatic. Not Stripe.
The first Vitalik Buterin project was Bitcoin Magazine. Not Ethereum.
The first Travis Kalanick startup was Scour. Not Uber.

Your first will not be your best.
But it is the only way to get there.

taplio

The Battle

Joe Rhew

Adam Fard

Followers

Posts

Engagements

Likes

Performance ScoreJoe Rhew's LinkedIn Performance

Performance ScoreAdam Fard's LinkedIn Performance

Ready to grow your LinkedIn presence?

taplio

The Battle

Joe Rhew

Adam Fard

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 ScoreAdam Fard's LinkedIn Performance

Ready to grow your LinkedIn presence?

Performance ScoreJoe Rhew's LinkedIn Performance