# Dele Tosh
> The engineer who thinks like a lawyer. 13+ years shipping products. Author of The Art of Product, co-founder of Protomated. Writing on building the right thing with AI.
Public Ghost content for AI and LLM tooling. This file includes a bounded export of public pages first, then recent public posts.
Append `.md` to any post or page URL to get the content in Markdown (for example, `/example-post.md`).
## Pages
### Home
URL: https://deletosh.com/home/
Last updated: 2026-02-24T23:00:44.000Z
I help founders build the right thing, and independent professionals  
stop losing ground to software that wasn't built for them.

13 years of engineering + product. Author of The Art of Product.  
Founder of Protomated.
### The engineer who thinks like a lawyer.
URL: https://deletosh.com/about/
Last updated: 2026-03-06T22:11:29.000Z
Before I became an engineer, I was going to be a lawyer. Systematic thinking. First principles. The habit of understanding the rules of a system before trying to operate inside it. That framing stayed with me through everything that followed.

Thirteen years of software engineering and product strategy. Work with companies most people have heard of - ThermoFisher Scientific, Parexel, Lufthansa, Deloitte. A stint as Director of Product at MOTUS. A book - *The Art of Product*. And eventually, the decision to stop building for large organisations and start building for the people they were leaving behind.

### The thing I kept seeing

The more sophisticated AI became, the harder it was for certain people to access its benefits. Not because they weren't capable. Because the tools were built for IT departments, enterprise budgets, and 12-week implementations.

Law firms running on paper and manual follow-up. Consultancies losing deals because nobody had time to write the follow-up email. Founders with genuinely good product ideas stuck in an IDE at 70% done, unable to figure out why the thing they built didn't quite fit the user they were imagining.

I've spent the last few years building into those gaps.

---

### What I'm building

**Protomated** is a studio I cofounded to build operations tools for independent professionals - solo attorneys and small firm lawyers (LegalContext), and consultants and agencies losing deals to slow follow-up (Salzy Meetings). The premise is simple: independent operators deserve the same quality of tooling as the firms they compete with, without the enterprise price tag or the IT department requirement.

**The Product Path** is the course I built because no structured, end-to-end process existed for going from a product idea to shippable code with Claude. It teaches the full pipeline - market research, documentation, user journey mapping, RICE scoring, sprint planning, and issue-by-issue development - using Claude and MCP integrations throughout. It's the process I use, documented so other builders don't have to figure it out themselves.

**Advisory work** runs alongside both. I work with a small number of founders and businesses at a time - early-stage founders figuring out what to build and how to take it to market, and organisations that need senior product input without a full-time hire. More on that here.

---

### Why this matters to me personally

I'm a Nigerian immigrant who grew up with very little. Scarcity teaches you to validate before you commit - to try a bit before you go all in. That instinct shaped my approach to product development more than any methodology I've studied.

As a Black person in America, I don't often get to be around a lot of people who look like me and are building at this level. Part of why I do this publicly - the writing, the course, the newsletter - is to make it visible that this kind of work is possible. Success isn't just revenue. It's doors opened.

I believe independent professionals and solo founders represent some of the most important work happening in the economy. They're the ones taking the risk without the safety net. They deserve tools and processes that actually work for them.

---

### The approach

A few things I believe that show up in everything I do:

**Validation before commitment.** Whether it's a product idea, a market strategy, or a hiring decision - try a bit first. The expensive mistake is the one you make six weeks in because you skipped the research.

**Simplicity is sophistication.** When we don't know something, we tend to overcomplicate things to cover for the naivety. The most advanced solution should be the easiest to use. If it requires an IT department, it's not done yet.

**First principles over trends.** Professional services will always have operational overhead. Client communication will always need to happen. Good products will always require understanding the user before building for them. These things don't change - the tools do.

**Independence over lock-in.** I have no interest in owning the ecosystem. I want founders and practitioners to own their future - not be held hostage by the platforms they rely on.

💡

13 years in software engineering and product strategy · Former Director of Product, MOTUS · Author, **The Art of Product* · Clients include ThermoFisher Scientific, Parexel, Lufthansa · Founder, Protomated
### Contact
URL: https://deletosh.com/contact/
Last updated: 2026-02-28T16:23:09.000Z
_No content available._
### Work
URL: https://deletosh.com/work/
Last updated: 2026-02-28T21:06:01.000Z
_No content available._
### The Produch Path - Dele Tosh
URL: https://deletosh.com/course/
Last updated: 2026-03-12T22:46:34.000Z
_No content available._
### Senior product and GTM input—without the full-time hire.
URL: https://deletosh.com/advisory/
Last updated: 2026-02-28T21:29:16.000Z
I work with a small number of founders and businesses at a time. The work ranges from helping a bootstrapped founder figure out their market and stack before committing to a build, to supporting an enterprise team through a product launch or upskilling programme.

If you're trying to figure out what to build, how to take it to market, or how to bring your team up to speed on new tooling — that's the work I do.

---

## Who This Is For

Two kinds of people typically reach out.

**Founders building early-stage products.** Usually pre-funding, often bootstrapped. The question isn't "can I build this?" — it's "should I build this, and if so, what's the fastest path to knowing if it works?"

I help founders get clarity on the market before they commit to a build, make pragmatic stack decisions that don't require venture money to sustain, and structure the product so the first version is something real customers can tell you about — not a prototype that sits in a GitHub repo.

**Organisations investing in their team.** The second type of engagement is typically with a business — sometimes an enterprise, sometimes a growing SMB — that needs its people upskilled on AI workflows, new product processes, or digital capability more broadly. This is structured training and enablement, not ad hoc coaching.

---

## What Clients Come With

Conversations usually start with one of these:

- *"I have a product idea but I'm not sure the market is real. I don't want to spend six months building the wrong thing."*
- *"We've been building for a while and it's not growing the way we expected. Something is off but I can't see it clearly."*
- *"We need our team to actually understand and use AI tools — not just have access to them."*
- *"I need someone who's shipped products and understands the commercial side, not just the engineering."*

---

## Track Record

I don't work with a large number of clients at once, and I don't share case studies by name. But to give you a sense of the kind of work this involves:

I've supported a product launch at a Fortune 500 company through to a successful M&A — acquired by private equity following the launch. That project involved product strategy, positioning, and cross-functional alignment across a large organisation.

On the SMB and upskilling side, structured training programmes I've run have measurably increased revenue per head — through better tools, better processes, and the team actually using both.

Thirteen years of product and engineering work. Former Director of Product at MOTUS. Clients have included ThermoFisher Scientific, Parexel, and Lufthansa. Author of *The Art of Product*.

The relevant credential isn't the name of the company — it's the decisions I've been trusted to make inside them.

---

## How We Work Together

**Retained advisory** A monthly engagement for founders or operators who need ongoing strategic access. Typically involves regular calls, async input on decisions, and review of product and GTM work as it develops. Right for founders who want a thinking partner across a longer arc — not just a one-time answer.

**Project-based work** Defined scope, defined output, defined timeline. Right for specific problems: a market analysis and stack recommendation before a build, a GTM strategy for a product about to launch, or a training programme for a team.

There's no fixed pricing on this page because the right structure depends on the work. The conversation comes first.

---

## TO START A CONVERSATION

Email me directly: [ask@deletosh.com](mailto:ask@deletosh.com)

Tell me what you're working on — one paragraph is enough. I'll reply within a couple of days and we'll figure out from there whether it makes sense to go further.

I'm selective about the engagements I take on. That's not a tactic — it's how I make sure the work is actually useful to the people I work with.
### Newsletter
URL: https://deletosh.com/newsletter/
Last updated: 2026-02-28T20:27:36.000Z
_No content available._
### The Product Path — Course Hub
URL: https://deletosh.com/product-path/
Last updated: 2026-03-12T22:47:01.000Z
_No content available._
### Thank You
URL: https://deletosh.com/thank-you/
Last updated: 2026-03-01T01:08:42.000Z
_No content available._
### Course Welcome
URL: https://deletosh.com/course-welcome/
Last updated: 2026-03-05T15:31:08.000Z
_No content available._
### The Foundry
URL: https://deletosh.com/foundry/
Last updated: 2026-03-06T22:06:19.000Z
_No content available._
### Welcome to the Foundry
URL: https://deletosh.com/foundry-welcome/
Last updated: 2026-03-06T22:06:41.000Z
_No content available._
## Posts
### Module 6, Lesson 13: Adding Stripe Payments with Claude Code: A Real Walkthrough
URL: https://deletosh.com/courses/product-path/06-13-adding-stripe-payments/
Last updated: 2026-08-15T04:42:48.000Z
_This post is for paying subscribers only._
### Module 6, Lesson 12: Testing Phase 3 on the Device
URL: https://deletosh.com/courses/product-path/06-12-test-phase-3-on-device/
Last updated: 2026-08-03T15:03:17.000Z
_This post is for paying subscribers only._
### Module 6, Lesson 11: Building Payments and OCR (Phase 3)
URL: https://deletosh.com/courses/product-path/06-11-build-payments-ocr-phase-3/
Last updated: 2026-07-31T11:46:18.000Z
_This post is for paying subscribers only._
### Module 6, Lesson 10: Building the Expense Lifecycle (Phase 2)
URL: https://deletosh.com/courses/product-path/06-10-build-the-expense-lifecycle/
Last updated: 2026-07-21T20:01:30.000Z
_This post is for paying subscribers only._
### Module 6, Lesson 9: Testing on a Real Device
URL: https://deletosh.com/courses/product-path/06-09-test-on-real-device/
Last updated: 2026-07-18T17:28:47.000Z
_This post is for paying subscribers only._
### Module 6, Lesson 8: Build & Completing Phase 1
URL: https://deletosh.com/courses/product-path/06-08-complete-phase-1/
Last updated: 2026-07-18T17:29:26.000Z
_This post is for paying subscribers only._
### Module 6, Lesson 7: Build the Profile Completion
URL: https://deletosh.com/courses/product-path/06-07-build-profile-completion/
Last updated: 2026-07-16T15:34:18.000Z
_This post is for paying subscribers only._
### Module 6, Lesson 6: Writing the Base Authentication
URL: https://deletosh.com/courses/product-path/06-06-write-base-auth/
Last updated: 2026-07-16T15:34:16.000Z
_This post is for paying subscribers only._
### Module 6, Lesson 5: Working the First Issue
URL: https://deletosh.com/courses/product-path/06-05-work-first-issue/
Last updated: 2026-07-16T15:34:15.000Z
_This post is for paying subscribers only._
### Module 6, Lesson 4: Testing the Scaffold Frontend (Mobile)
URL: https://deletosh.com/courses/product-path/06-04-test-scaffold-mobile/
Last updated: 2026-07-17T00:14:36.000Z
_This post is for paying subscribers only._
### Module 6, Lesson 3: Testing the Scaffold Frontend (Web)
URL: https://deletosh.com/courses/product-path/06-03-test-scaffold-web/
Last updated: 2026-07-16T15:34:12.000Z
_This post is for paying subscribers only._
### Module 6, Lesson 2: Testing the API Scaffold
URL: https://deletosh.com/courses/product-path/06-02-test-api-scaffold/
Last updated: 2026-07-17T00:14:13.000Z
_This post is for paying subscribers only._
### Module 6, Lesson 1: Scaffolding the Project
URL: https://deletosh.com/courses/product-path/06-01-scaffolding-project/
Last updated: 2026-07-16T15:34:09.000Z
_This post is for paying subscribers only._
### Module 5, Lesson 5: Connect Project to GitHub
URL: https://deletosh.com/courses/product-path/05-05-connect-github/
Last updated: 2026-07-16T15:34:08.000Z
_This post is for paying subscribers only._
### Module 5, Lesson 4: Connect Claude Design to Claude Code
URL: https://deletosh.com/courses/product-path/05-04-connect-claude-design/
Last updated: 2026-07-16T15:34:06.000Z
_This post is for paying subscribers only._
### Module 5, Lesson 3: Designing the App
URL: https://deletosh.com/courses/product-path/05-03-designing-the-app/
Last updated: 2026-07-16T15:34:05.000Z
_This post is for paying subscribers only._
### Module 5, Lesson 2: Building the Design System
URL: https://deletosh.com/courses/product-path/05-02-building-the-design-system/
Last updated: 2026-07-16T15:34:03.000Z
_This post is for paying subscribers only._
### Module 5, Lesson 1: The Build Pre-reqs
URL: https://deletosh.com/courses/product-path/05-01-build-pre-reqs/
Last updated: 2026-07-16T15:34:01.000Z
_This post is for paying subscribers only._
### Module 4, Lesson 8: Design and Launch Your Facebook Ad
URL: https://deletosh.com/courses/product-path/04-08-launch-facebook-ad/
Last updated: 2026-07-16T15:33:59.000Z
## Why do you need a success page for a Facebook conversion event?

You need a success page because the only way a visitor can reach the /success URL is by completing your landing page form, which gives Facebook a reliable signal that a real lead converted rather than just a click.

You build the success page with Claude Code, then configure a custom conversion event in Facebook that fires when someone lands on it. In this lesson you also design the ad images with Claude from the Lesson 7 brief and launch a live ad with the right targeting, creatives, and UTM tracking, closing the loop from ad click to tracked conversion.

**The short version: you build the creative, point it at your tracked landing page, and launch with real spend so demand gets validated by actual clicks and signups, not opinion. This is where the whole pipeline meets the market. The full creative and launch steps are inside The Product Path.**

## Before We Start

**From previous lessons:**

- Your landing page is live with a ConvertKit form connected, [Module 4, Lesson 1](https://deletosh.com/courses/product-path/04-01-design-landing-page/)
- The Meta Pixel is installed and verified working on your site, [Module 4, Lesson 7](https://deletosh.com/courses/product-path/04-07-plan-facebook-campaign/)
- You have a campaign plan document from Claude, [Module 4, Lesson 7](https://deletosh.com/courses/product-path/04-07-plan-facebook-campaign/). This includes your ad brief with audience angles, headline options, primary text, and ad copy. You’ll need this for the creative work in this lesson
- Your full document set from [Module 2](https://deletosh.com/404/) is accessible (GTM doc, market research, summary)

**Tools / setup you’ll need:**

- Facebook Ads Manager (in Business Suite)
- Claude Desktop with your documents folder or Co-work project accessible
- Your live site URL, you’ll need both the main URL and the `/success` path
- The campaign brief from Lesson 7 handy

**By the end of this lesson, you’ll:**

- Have a success/thank you page live on your site (and know why it matters for conversion tracking)
- Have a custom conversion event configured in Facebook that fires when someone reaches that page
- Have designed your ad images using Claude, no Canva needed
- Have an ad live in Facebook Ads Manager with the right targeting, creatives, and UTM tracking

---

## What Is This Lesson About?

**Duration:** \~17 minutes video + \~30 minutes setup   
**Skill Level:** Beginner   
**What You’ll Build:** A live Facebook ad with a working conversion event, the full loop from ad click to tracked conversion.

This is where everything we’ve built comes together and faces the real world. A landing page with no traffic is just a nice-looking page. This lesson is about closing the loop: drive traffic, track what works, and start gathering the signal you’ll use to iterate.

---

## Watch the Lesson

<iframe src=“[https://iframe.mediadelivery.net/embed/605189/fe6b7345-b051,41a0,96ce-fe0029117e46](https://iframe.mediadelivery.net/embed/605189/fe6b7345-b051-41a0-96ce-fe0029117e46?ref=deletosh.com)” allow=“autoplay; fullscreen; picture-in-picture” allowfullscreen loading=“lazy” style=“width:100%; aspect-ratio:16/9; border:none; border-radius:0;”>

---

ℹ️

****How I’d suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section, pausing the video at the timestamps I’ve noted. After that, this guide is your reference, you shouldn’t need to rewatch to look something up.

---

## What We’re Covering

Here’s what I’m walking you through in this lesson:

- **The success page and why it exists**: it’s not just a nice UX touch; it’s what makes your conversion event work
- **Creating a custom conversion event in Facebook**: so you’re tracking real leads, not just clicks
- **Designing your ad images with Claude**: using the brief from Lesson 7, no design tool required
- **Configuring the ad in Facebook Ads Manager**: audience, placement, budget, copy, UTMs, and going live

---

## 1\. The Success Page: Why You Need It *(\~0:00)*

Before we touch Facebook, there’s something you need to have in place on your site: a success page.

Here’s how the user journey works. Someone sees your ad, clicks through to your landing page, puts in their email, and hits “Get Early Access.” That form submit goes to ConvertKit, we set that up in Module 4, Lesson 2\. But from the user’s point of view, what happens next? They need to land somewhere.

That’s the success page. And it does two things:

1. **It confirms to the user that something happened.** “You’re in. We’ll be in touch.” Simple.
2. **It gives Facebook something to track.** The only way someone can land on `/success` is if they completed the form. So when Facebook sees that URL, it knows: this person converted.

Without this page, you can’t set up a reliable conversion event. You’d be tracking clicks to your landing page, not actual leads.

### Building the Success Page with Claude

I used a simple prompt to have Claude Code build this for me. The prompt is included in the notes below, feel free to use it as a starting point:

```
I want to create a thank you page they will be redirected to so I can create a Facebook conversion event around it.
Ask me all the clarifying questions you need.

```

💡

Let Claude ask its questions first. It’ll want to know things like: what should the page say, what happens after they land here, are you collecting additional info. Answer them honestly, the more context it has, the better the page it builds.

In my version, the success page does something a bit more than just say “thanks.” After someone signs up with their email, I ask for their name and phone number. Why? Because it’s much easier to reach people by text or a quick call than by email alone, especially for early validation conversations. I want to talk to these people.

The reason I don’t ask for this on the first page is straightforward: asking for too much up front kills conversions. Get the email first. Once they’ve committed, they’re on the page, they’ve given you something, then ask for a bit more. The psychology there is solid.

When they submit that second form, it updates their ConvertKit subscriber record with their name and phone number. That’s the full loop.

**Have these two URLs ready before you start in Facebook:**

- Your main page URL (e.g. `nurturo.app`)
- Your success page URL (e.g. `nurturo.app/success`)

---

## 2\. Setting Up the Custom Conversion Event *(\~4:46)*

Now go into Facebook Ads Manager. You should already have your campaign created from Lesson 7, we set up the Business account, the Ad account, and installed the pixel. Now we need to tell Facebook what “success” looks like.

### What is a Conversion Event?

A conversion event is a specific action that means something real happened. Not “someone clicked your ad”, that’s just traffic. A conversion, in our case, is “someone landed on `/success`,” which means they gave us their email. That’s a lead.

Facebook tracks this using the pixel we installed in Lesson 7\. When the pixel fires on the `/success` page, Facebook logs it as a conversion.

### Creating the Custom Conversion

1. In Ads Manager, go to **Campaigns** and make sure you have the right Ad account selected
2. Click **Create** and choose **Generate Leads** as your campaign objective, this is about getting conversions, not impressions
3. Name your campaign something clear. Mine is “Nurtoro Better, Pre-launch Lead Generation"
4. When asked about budget level, set it at **ad set level**, not campaign level. I’ll explain why in a moment

Now, before you go further, you need to create the custom conversion. Here’s how:

1. When you reach the conversion event selection, choose **Create Custom Conversion**
2. Give it a clear name, I used “Complete Registration, Gives Info for Early Access”
3. Select your pixel (make sure it shows as **green**: that means it’s active and receiving data)
4. Set the **Website Source** to **All Traffic**
5. Set the **Rule** to: URL **contains** `/success`
6. Leave the conversion value as-is for now
7. Click **Create**

ℹ️

Facebook will likely show a warning that it “hasn’t received this conversion event yet.” That’s normal, it just means no one has hit that URL since you created the event. It’ll populate once real traffic comes through. Don’t let that stop you from proceeding.

Now select that custom conversion as your event. You should see it in the dropdown under your pixel.

---

## 3\. Configuring the Ad Set *(\~6:42)*

This is where you define who sees your ad and how much you spend. Your answers here will be different from mine, they should come from the brief you generated with Claude in Lesson 7.

### Budget

I’m running at **$5/day**, set at the **ad set level**. Here’s why I chose ad set over campaign level: I want to test different audience angles separately. Setting the budget at the campaign level means Facebook controls how it’s spread. Setting it at the ad set level means I control it. For testing, that’s what I want.

### The Ad Set Structure: Campaigns, Ad Sets, and Ads

Quick orientation on how Facebook structures this, because it trips people up:

- **Campaign**: the big goal. In our case: get early access leads
- **Ad Set**: a cluster of ads targeting the same audience angle. Think of this as “the theme”
- **Ad**: the individual creative (image + copy)

I’m testing one angle first: **frustrated parents**. That’s one ad set. If I were also testing “recently divorced parents” or “parents with teenagers,” those would be separate ad sets with their own budgets and targeting.

### Audience

Your audience targeting should come from your brief. Mine is:

- **Location:** Specific US states (I bulk-added these)
- **Age:** 28,45
- **Gender:** All genders (I stated skewed female but let the data decide)
- **Interests & behaviours:** Parents with children under 17, single parents, parenting-related interests

One important note: Claude’s suggestions for interests are a starting point, not gospel. When I ran it, the combination Claude suggested, parenting + Venmo + financials + recently married, wasn’t a good fit. That’s too broad for a $5/day test. I brought it down to around 5 million by stripping out the looser interests and focusing on: parents with kids 0,17, single parents, basic parenting interests.

**Keep your audience under 10 million for early testing.** Broad audiences eat budget without teaching you anything useful.

### Placement

I kept it tight:

- **Mobile only**: most people scroll on their phones
- **Facebook + Instagram**: no Threads, no Messenger, no Audience Network
- **Reels, Feed, and Stories**: the placements that match the image formats we’re creating

---

## 4\. Designing the Ad Images with Claude *(\~13:29)*

Here’s the part I enjoyed most. You don’t need Canva. You don’t need a designer. Claude can build your ad images directly.

Go to your Claude Desktop co-work project (or wherever you’ve been working with your documents). I used this prompt:

```
Design the image for my ad

Image size: 1080 × 1080px (square) — works in Feed, Stories crop, and Reels
Also create: 1080 × 1920px (9:16) for Stories/Reels placement
Font: Clean sans-serif (use Google Font equivalent — DM Sans or Raleway)

[paste your ad brief here or let it infer from the cowork]

Ask me questions for clarity.

```

💡

Always let Claude ask its clarifying questions. It’s going to want to know: what’s the main message, what’s the visual tone, do you have brand colours, is there a specific CTA. Answer them thoroughly, this is where the brief from Lesson 7 pays off. You’ve already done this thinking.

What you’ll get back are two images:

- One **1080 × 1080px** square for Feed
- One **1080 × 1920px** vertical for Reels/Stories

These are ready to upload directly into Facebook Ads Manager. No post-processing needed.

ℹ️

The image Claude generates is based on the SVG/HTML spec it writes, not a rasterised photo. It’ll be clean, text-forward, and design-coherent. That actually works well for direct response ads: clear message, readable copy, strong CTA. Don’t expect a lifestyle photograph, expect something closer to a clean graphic ad.

---

## 5\. Building the Ad in Ads Manager *(\~12:03)*

Now you’re in the Ad section, the creative layer. A few things to get right here.

### Select Your Facebook Page

Make sure you’ve selected the right Facebook Page. If you don’t see your page in the dropdown, you probably didn’t connect it to your Business account properly in Lesson 7\. Go back and check.

### Ad Format

Choose **Single Image** and **Manual Upload**. Don’t use existing posts, don’t use video for now, keep it simple.

### The Website URL (With UTM Parameters)

This is where people often just paste their URL and move on. Don’t do that. You want the full URL with UTM parameters, this is how you’ll know, later, which specific ad set and creative is driving conversions.

Your URL should look something like:

```
https://yourapp.com?utm_source=facebook&utm_medium=paid_social&utm_campaign=pre-launch

```

Your ad brief from Claude in Lesson 7 should have included a version of this. Copy the full URL including the UTM string, not just the base URL.

For the **Display Link**, use your clean URL without UTMs (e.g. `nutoro.app`). That’s what users see, the UTMs are just for your tracking.

### Uploading Your Images

- Upload the **square (1080 × 1080px)** for the main Feed placement
- Upload the **vertical (1080 × 1920px)** for Reels/Stories

Facebook will show you a preview for each placement. Check them, make sure nothing is cropped awkwardly.

### Copy: Headline, Primary Text, Description

This all comes from your brief. Mine looked like:

- **Headline:** “Stop managing child expenses in your texts.”
- **Primary text:** "It shouldn’t take a $250/hour attorney to prove you paid for your kid’s prescription…”

Don’t write this from scratch, pull it from the brief Claude generated. That’s what it’s there for.

### Final Checks Before Publishing

- Pixel selected? ✓
- Custom conversion event selected? ✓
- URL includes UTM parameters? ✓
- Images uploaded for all placements? ✓
- Headline and copy pasted in? ✓

Once you’re satisfied with the preview, hit **Publish**.

Facebook will process it. It usually takes a few hours to a day for review. Once it’s approved, it’ll go live.

✅

You’re live. That’s the whole loop: landing page → ConvertKit → PostHog → Meta Pixel → conversion event → ad running. We’ll come back in a few days to review the data.

---

## Watch Out For These

⚠️

****Pixel showing as inactive or “not received”**  
This usually means the pixel isn’t firing correctly on your success page. Go back to Module 4, Lesson 7 and re-verify the pixel is installed. Use the Meta Pixel Helper browser extension to check. Don’t proceed until you see the pixel is green in Ads Manager.

⚠️

****Audience size too large (100M+)**  
This means your interest targeting is too broad. Claude’s suggestions are a starting point, use human judgment to narrow them. Strip out loosely related interests and focus on the tightest definition of your actual target person. Aim for under 10 million for early testing.

⚠️

****Forgetting to paste the UTM URL**  
Easy to miss. If you paste just your base URL, you’ll get conversions but you won’t know which ad set or creative drove them. Always paste the full URL with UTM parameters in the destination URL field. Keep your clean URL for the display field only.

⚠️

****No page selected in the Ad section**  
If the ad section looks empty or options are greyed out, you probably haven’t selected your Facebook Page. Look for the page selector at the top of the Ad configuration, select it before doing anything else.

---

## Try It Yourself

### Exercise 1: Build the Success Page

Use the prompt from Section 1 to have Claude Code build your success page. Make sure:

- It lives at `/success` (or whatever path you’re tracking)
- It redirects correctly from your form submit
- It loads cleanly in the browser

**How you’ll know it’s working:** Submit a test entry on your landing page and confirm you land on the success page. Then check ConvertKit, the subscriber should be there.

### Exercise 2: Design Your Ad Images

Use the image design prompt from Section 4 with your own brief. Let Claude ask its questions, give detailed answers, and export both image sizes.

**Now try this:** Upload them to Facebook and compare how they look in the Feed preview vs the Reels preview. Adjust the prompt if anything looks wrong.

### Exercise 3: Publish Your First Ad

Work through Sections 2,5 in sequence. Don’t skip the custom conversion setup, that’s what makes the whole thing measurable.

**How you’ll know it’s working:** Ad status shows “In Review” or “Active” in Ads Manager, and your custom conversion event shows as configured.

---

## 6\. You Should Be Able to Build This Now

Here’s what you can do with what we just covered:

- Build a post-conversion page that doubles as a Facebook tracking trigger
- Create a custom conversion event tied to a specific URL
- Generate ad-ready images for Facebook Feed and Reels using Claude
- Configure and publish a conversion-optimised Facebook ad with full tracking

### Check Yourself

- My success page is live and accessible at `/success`
- A custom conversion event is set up in Facebook tied to that URL
- I have ad images in both square and 9:16 formats
- My ad is published with UTM parameters in the destination URL
- The Meta Pixel is green and associated with my ad

✅

If you’re ticking those boxes, you’ve shipped. An ad is live, a real product is being promoted, and you’re tracking real conversions. That’s the course. Nice work.

---

## The Short Version

Here’s what I want you to walk away with:

- **The success page is your conversion event trigger:** Without it, Facebook can’t measure what “working” looks like
- **Custom conversions beat standard events:** Tracking a specific URL is more reliable than relying on generic pixel events
- **Claude can design your ad creative:** Use your brief as the input; you get two images ready to upload
- **UTM parameters are non-negotiable:** They’re how you’ll eventually know which ad, angle, and audience is actually converting
- **Start narrow, not broad:** A $5/day ad with a 5M focused audience will teach you more than $50/day aimed at everyone

---

## Quick Reference

### Key URLs to Have Ready

```
Main URL:    https://yourapp.com
Success URL: https://yourapp.com/success
Ad URL:      https://yourapp.com?utm_source=facebook&utm_medium=paid_social&utm_campaign=pre-launch

```

### Ad Image Sizes

```
Square:   1080 × 1080px — Feed, Stories (cropped), Reels (cropped)
Vertical: 1080 × 1920px — Reels, Stories (full bleed)

```

### Ad Copy Structure

```
Headline:       Short, punchy — addresses the pain directly (max ~40 chars)
Primary Text:   Expands the problem and introduces the solution (2–3 sentences)
Description:    Feature-level detail — what the product actually does (1 sentence)
Display Link:   Clean URL only (no UTMs)
Destination URL: Full URL with UTM parameters

```

### Claude Prompts Used in This Lesson

**Success page:** `I want to create a thank you page they will be redirected to so I can create a Facebook conversion event around it. Ask me all the clarifying questions you need.`

**Ad image design:** \`\`\` Design the image for my ad

Image size: 1080 × 1080px (square), works in Feed, Stories crop, and Reels Also create: 1080 × 1920px (9:16) for Stories/Reels placement Font: Clean sans-serif (use Google Font equivalent, DM Sans or Raleway)

\[paste your ad brief here\]

Ask me questions for clarity. \`\`\`

---

## Resources

### Tools Used

- [Facebook Ads Manager](https://business.facebook.com/?ref=deletosh.com)where you build and manage campaigns
- [Meta Pixel Helper](https://chromewebstore.google.com/detail/meta-pixel-helper/fdgfkebogiimcoedlicjlajpkdmockpc?ref=deletosh.com)Chrome extension to verify your pixel is firing *(came up in Module 4, Lesson 7)*
- [Google Fonts, DM Sans](https://fonts.google.com/specimen/DM+Sans?ref=deletosh.com)the font Claude used in the ad images

---

## Questions I Get Asked

**Q: Why not just use the standard “Lead” conversion event from Facebook instead of creating a custom one?**

The standard Lead event is a generic signal, it can fire in a lot of contexts. By creating a custom conversion tied to `/success`, I’m being precise: I’m tracking only people who completed my specific form, on my specific page. That’s cleaner data, especially at low volume where every data point matters.

**Q: Do I need a designer to make good ad images?**

Not for a pre-launch test. The images Claude generates are clean, text-forward, and appropriate for direct response. They’re not going to win a design award, but they communicate the message clearly, which is what matters for a $5/day validation run. If you get traction and want to scale, then invest in proper creative.

**Q: Can I change the ad after it’s published?**

Yes, but every significant edit resets the learning phase and sends it back into review. For early testing, try to commit to an ad and let it run for at least 3,5 days before tweaking. Change one thing at a time so you know what caused any shift.

**Q: How do I know I’m ready for the next lesson?**

If your ad is live and your conversion event is configured, you’re done here. The next step is waiting for data, then coming back to interpret it.

---

## 💬 Stuck? Come Talk to Us

💡

If something’s not clicking or you want to share what you’ve built, come find us in Discord.  
****Build What Ships community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community’s active and I check in there too.

---

## Glossary

**Custom Conversion Event:** A rule you define in Facebook that says “this action = a conversion.” In our case, it’s “user lands on `/success`.” More precise than standard events. *(first came up in this lesson)*

**UTM Parameters:** Tags you add to a URL (e.g. `?utm_source=facebook`) that tell your analytics tools where traffic came from. Essential for attribution. *(we used these in Module 4, Lesson 7 - Plan Your Facebook Campaign & Install the Meta Pixel)* **Ad Set:** The middle layer in Facebook’s campaign structure. Sits between the campaign (the goal) and the individual ad (the creative). Controls audience, budget, and placement.

**Conversion:** When a user takes the specific action you’ve defined as success. In our case: submitting the early access form and landing on the success page.

**Meta Pixel:** The tracking script installed on your site that connects your website activity to Facebook’s ad platform. *(installed in* [*Module 4, Lesson 7*](https://deletosh.com/courses/product-path/04-07-plan-facebook-campaign/)*)*

**Placement:** Where your ad appears, Feed, Reels, Stories, etc. Choosing placements manually (rather than letting Facebook decide) gives you more control over spend and format.
### Module 4, Lesson 7: Plan Your Facebook Campaign & Install the Meta Pixel
URL: https://deletosh.com/courses/product-path/04-07-plan-facebook-campaign/
Last updated: 2026-07-16T15:33:57.000Z
## What is the Meta Pixel and why install it before running ads?

The Meta Pixel is a snippet of tracking code you place on your live site so Facebook can measure what visitors do after they click your ad, which is what makes conversion trackable rather than guessed. You install it before running ads so every dollar of spend is a measurable test instead of a gamble.

In this lesson you set up a Facebook Business and Ad account, feed your Module 2 docs into Claude to generate a full pre-launch campaign plan (objective, audience, creatives, UTM tags, metrics), then use Claude Code to install and verify the pixel.

**The short version: you define the campaign structure and install the Meta Pixel so the traffic you send to your landing page is tracked and conversion is measurable from the start. Tracking upfront is what makes ad spend a test rather than a gamble. The full plan is inside The Product Path.**

In this lesson, I’m picking up from having a live, tracked landing page, and now we need to actually get people to it.

ℹ️

One thing worth flagging: the GTM document we generated in Module 2, Lesson 6 actually recommends **against* Meta ads at low budget, calling it below minimum viable spend for a consumer app. I want to be transparent about that. What we’re doing here isn’t contradicting the GTM plan, it’s supplementing it with a small-budget validation experiment before we’re fully built. The goal is data, not scale. Keep that in mind as we go through this.

---

## Before We Start

**From previous lessons:**

- Your landing page is live, Module 4, Lesson 1
- PostHog is installed and tracking, Module 4, Lesson 5
- Your reverse proxy is set up so ad blockers don’t interfere, Module 4, Lesson 6
- You have your full document set from Module 2: Market Research, Summary, and GTM. If you’re following along with your own app, these are the docs you produced in Module 2, Lessons 1,6, you’ll be feeding them into Claude in this lesson

**Tools / setup you’ll need:**

- A Facebook personal account (required to create a Business account)
- Claude Desktop with Co-work or your documents folder accessible
- Claude Code running in WebStorm terminal (for the pixel install)
- A GitHub → Vercel deployment pipeline already working

**By the end of this lesson, you’ll:**

- Have a Facebook Business account and Ad account ready to run ads
- Have used Claude to generate a complete Facebook pre-launch campaign plan from your product docs
- Know what questions Claude will ask you, and the right answers to give
- Have the Meta Pixel installed on your live site and verified it’s working
- Understand the full structure of a pre-launch ad campaign: objective, audience, creatives, UTM tags, and metrics

---

## What Is This Lesson About?

**Duration:** \~13 minutes video + \~20 minutes practice **Skill Level:** Beginner **What You’ll Build:** A ready-to-run Facebook pre-launch campaign plan, plus a working Meta Pixel on your live site.

Here’s the thing about pre-launch traffic: you can’t just publish a page and hope people show up. The landing page is live, tracking is working, but none of that matters if no one visits it. This lesson is about getting your first real visitors, gathering data on what resonates, and building an audience before the app is ready to ship. Meta ads, even at $5,10/day, give you that signal faster than almost anything else at this stage.

---

## Watch the Lesson

---

ℹ️

****How I’d suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section, pausing the video at the timestamps I’ve noted. After that, this guide is your reference, you shouldn’t need to rewatch to look something up.

---

## What We’re Covering

- **Facebook Business setup**: the prerequisite steps: creating a Page and Ad Account so Meta will actually let you run ads
- **Using Claude to plan the campaign**: how to feed your product docs into Claude and get a complete, structured campaign plan back
- **What to answer when Claude asks questions**: the clarifications that actually shape the output
- **Installing the Meta Pixel**: how to get the tracking code onto your live site in under 5 minutes, using Claude Code
- **Verifying it works**: how to confirm the pixel is firing before you spend a single dollar

---

## 1\. Let’s Set the Scene *(\~0:00)*

At this point, you should have your landing page set up, tracking is working, and things are looking good. But here’s the reality: a page without traffic is just a page. Especially for pre-launch, especially for what we’re doing, you have to drive traffic there.

For most apps at this stage, Meta ads, Facebook ads, is one of the cheapest ways to get real people to your page. And I want to be clear about what we’re trying to accomplish here. We haven’t built the full product yet. What I want is to put this in front of real people so that by the time we’re shipping, we already have a pool of people who’ve said “yes, I’m interested.” That’s the goal. Not scale. Not ROI. Data and early adopters.

---

## 2\. Setting Up Your Facebook Business Account

### 2.1 Create the Business Account

Before you can run any ads, you need a Facebook Business account. Head to [**business.facebook.com**](https://business.facebook.com/?ref=deletosh.com): not regular [facebook.com](https://facebook.com/). This is the business and advertising side of Facebook. If you don’t have a Facebook personal account yet, you’ll need to create one first.

Once you’re in, it’ll create a business account for you.

### 2.2 Create a Facebook Page

Meta requires you to have a Facebook Page attached to your account before you can run ads. We’re not doing anything with this page, no organic content, no followers. It just needs to exist.

Go to **Settings → Pages** and create a new page. Name it after your app. For the category, pick whatever fits closest (for Nurturo I used “Parenting”). That’s it, create it, confirm it shows up, and move on. You won’t be touching this page again for a while.

### 2.3 Set Up an Ad Account

Still in Settings, go to **Ad Accounts** and create one. You’ll be asked to add a payment card, this is what Meta will charge when your ads run. Set it up and confirm the account exists.

ℹ️

These three things, Business account, Page, and Ad Account, are the prerequisites Meta needs before you can launch anything. Get them sorted now so there’s no friction when you’re ready to hit go.

---

## 3\. Using Claude to Plan the Campaign *(\~2:47)*

This is the main event. We’re going to feed your product documents into Claude and have it generate a complete Facebook pre-launch campaign plan, structured, research-backed, and tailored to your app.

### 3.1 What to Have Open

Open Claude Desktop and make sure you’re in Co-work mode (or have your documents accessible). The documents you’ll be referencing are the ones you produced back in Module 2:

- **Market Research** (Module 2, Lesson 1,2)
- **Summary** (the distilled version from Module 2)
- **GTM Document** (Module 2, Lesson 6)

Claude is going to read these and use them as grounding context for everything it produces. This is the whole point of doing the research and documentation first, it pays off here.

⚠️

I’m using Sonnet 4.6 for this, not Opus. The reason is simple: this is a long prompt with a lot of context, and I don’t want to burn through tokens too fast. Sonnet handles this kind of structured research task well. If you’re on a plan with usage limits, keep that in mind.

### 3.2 The Prompt Structure

Here’s the shape of the prompt I used, adapt this for your own app:

```
Review the following in my folder:
- App - [Your App Name] - Market Research
- App - [Your App Name] - Summary

And based on this, design a Facebook campaign to drive initial early adopters to my page for the pre-launch.

I have a maximum budget of $5–$10/day, capped at $150 total.

The page is at [your-app-url]

Here are the core things I need:
- The best ad structure
- Creatives
- Audience
- Relevant UTM tagging
- Metrics to track
- Success metrics

Review and do deep research on this, and before you write it, ask me all the relevant questions you have.

```

The key line at the end is: **ask me all the relevant questions first**. Don’t let Claude just run with it immediately. You want to answer a few clarifying questions before it writes anything, that’s what shapes the output.

### 3.3 The Questions Claude Will Ask (and How to Answer Them)

Claude will come back with clarifying questions before it writes the plan. Here’s what I got asked, and the answers I gave, use these as a guide for what to think through for your own app:

**Call to action, what do you want people to do when they land on the page?**

Not “join a waitlist.” Waitlists feel passive and cheap. I want “sign up for beta”, the framing that you’re going to *try* the app. It’s a stronger commitment signal from people who actually intend to use it.

**What creative assets do you currently have?**

Be honest here. If you don’t have video recordings of the app, say so. At this stage I only had the landing page, no app demo, no screenshots of working features. That shapes the creative direction: copy-heavy ads, strong headline, simple design direction. Claude will work with whatever you have.

**Who is the primary emotional persona you’re targeting?**

This one is interesting because you probably have a few candidate audiences. My answer: test all three angles, let the data decide. We made assumptions in the research phase, now we’re putting it in front of the real world to see what resonates. That’s exactly what low-budget testing is for.

**Do you have the Meta Pixel installed?**

At the time I ran this prompt, no. I told Claude the pixel wasn’t installed yet. This is fine, it doesn’t block the planning. We install the pixel at the end of this lesson. Claude notes it as a prerequisite but writes the plan assuming you’ll have it sorted before the campaign goes live.

**Do you have a Meta Business account and Ad Account set up?**

Yes, because we did that in Section 2 above. This is why we set it up first.

### 3.4 What Claude Produces

After you answer the questions, Claude will run its research and generate a campaign document. It writes this directly into your notes folder (if you’re using Co-work with Obsidian or a local folder connection). The output covers:

- **Campaign objective**: what to optimize for at your budget level
- **Ad set structure**: how many ad sets, what audience targeting for each
- **Creative direction**: what the ads should look like given what you have available
- **UTM tag structure**: how to tag your links so PostHog knows where traffic is coming from
- **Metrics to watch**: what to look at inside Ads Manager
- **Success metrics**: how to know if this experiment is working or if you should kill it

ℹ️

The campaign doc Claude produces isn’t final ad copy, it’s a strategic plan. Think of it as your brief. You’ll take the creative direction and write the actual ad copy yourself, or have Claude help you with that as a separate step once the plan is set.

### 3.5 Why UTM Tags Matter Here

UTM parameters are the link tracking codes that tell PostHog (and eventually Google Analytics, if you add it) exactly where each visitor came from. Without them, all your Facebook traffic shows up as “direct” and you have no idea which ad, which audience, or which creative is working.

A typical UTM-tagged link for this campaign looks like:

```
https://yourapp.com/?utm_source=facebook&utm_medium=paid_social&utm_campaign=prelaunch&utm_content=audience-1-creative-a

```

Claude will generate the full UTM structure for you as part of the campaign plan. The key thing to understand is that `utm_content` is where you differentiate between ad variants, so when you’re looking at PostHog later, you can see which specific ad drove the most signups.

---

## 4\. Installing the Meta Pixel *(\~8:18)*

The Meta Pixel is a small piece of JavaScript that sits in your site’s `<head>` tag. It tells Facebook when someone visits your page, which is what enables the ad targeting and conversion tracking. Without it, you’re flying completely blind on the ad side.

### 4.1 Create the Pixel in Meta

Back in [**business.facebook.com**](https://business.facebook.com/?ref=deletosh.com), go to **Settings → Data Sources → Datasets**. Click **Add**, name your pixel after your app (e.g. “Nurturo App”), connect it to the Ad Account you created earlier, and click through.

Meta will then walk you to **Events Manager**, where you’ll find the pixel setup flow. Choose **Install Code Manually**: this gives you a code snippet to copy.

**Copy that code snippet.** You’ll paste it into Claude in a moment.

### 4.2 Install It via Claude Code

Don’t manually edit your HTML or React files. Just open Claude Code (in your WebStorm terminal) and give it a simple prompt:

```
Setup meta pixel

[paste the pixel code snippet here]

```

Claude will find the right place in your codebase, the `<head>` section of your layout file, and insert the pixel code correctly. Once it’s done, tell it to **commit and push**.

Because your GitHub → Vercel pipeline is already set up (Module 4, Lesson 3), that commit will automatically trigger a deployment. Your live site will be updated within a minute or two.

### 4.3 Verify It’s Working

Install the **Meta Pixel Helper** Chrome extension, search for it in the Chrome Web Store and add it. Then navigate to your live site, refresh the page, and click the extension icon in your toolbar.

You should see:

- The pixel ID detected on the page
- A **PageView** event firing

That PageView event is the critical one. It means Meta is successfully receiving data from your site. You’ll also see this confirmed in Events Manager, your pixel should show as **Active**.

✅

If the Pixel Helper shows your pixel ID and a PageView event, you’re done. Everything is wired up. You can now run ads and Meta will be able to track what happens when people land on your page.

ℹ️

When Events Manager asks about “Advanced Matching” (email address, phone number, etc.), this helps Meta match website visitors to Facebook profiles for better targeting. It’s optional, but I leave it on. If the data sharing concerns you, you can skip it. It won’t affect whether the pixel works for basic tracking.

---

## 5\. Watch Out For These

⚠️

****Running the campaign before the pixel is installed**  
Why this happens: It’s tempting to just get the ads live. But without the pixel, Meta has no conversion data, it can’t optimise your campaign, and you can’t see which ad drove signups in PostHog.  
How to avoid it: Always confirm the Pixel Helper shows a PageView event before you activate any ad sets.

⚠️

****Skipping the questions and letting Claude just write the plan**  
Why this happens: The prompt says “ask me questions first” but it’s easy to miss that line or skip it when you’re in a hurry.  
How to avoid it: Keep that instruction in the prompt. The questions Claude asks, about your CTA, your assets, your target persona, directly shape what it produces. A plan without those inputs is a generic plan. You want something grounded in your specific situation.

⚠️

****Not using UTM tags on your ad links**  
Why this happens: It’s easy to forget, especially when you’re figuring out the Ads Manager UI for the first time.  
How to avoid it: Claude generates your UTM structure as part of the campaign plan. Copy it and use it. If you go live without UTMs, PostHog won’t attribute the traffic correctly and you’ll have no way to know what’s working.

⚠️

****Using “join the waitlist” as your CTA**  
Why this happens: It’s the default, every template and tutorial uses it.  
Why it’s wrong: “Waitlist” signals you’re not ready. It’s passive. “Sign up for beta” signals that people are going to actually use the thing. It attracts a higher-intent signup and sets the right expectation. Use “sign up for beta” or “get early access” instead.

---

## 6\. Practice

### Exercise 1: Set Up the Facebook Prerequisites

**What to do:** Create a Facebook Business account, add a Page for your app, and set up an Ad Account with a payment method. Don’t run any ads yet, just get the infrastructure in place.

**How you’ll know it’s working:** You can navigate to [business.facebook.com](https://business.facebook.com/?ref=deletosh.com), see your Page listed under Pages, and see your Ad Account listed under Ad Accounts with a status of Active.

### Exercise 2: Run the Campaign Planning Prompt

**What to do:** Open Claude Desktop, point it at your Market Research and Summary documents from Module 2, and run the campaign planning prompt from Section 3.2\. Answer Claude’s clarifying questions honestly, especially the ones about what creative assets you have and what your CTA is.

**A nudge if you’re stuck:** If Claude doesn’t ask you questions before writing, check that the last line of your prompt explicitly says “before you write it, ask me all the relevant questions.” If it’s already written a plan, start a fresh conversation and try again.

**How you’ll know it’s working:** Claude produces a structured document covering ad structure, audience, creatives, UTM tags, and metrics, and it’s saved to your notes or project folder.

### Exercise 3: Install and Verify the Meta Pixel

**What to do:** Create a pixel in Meta Events Manager, copy the code snippet, install it via Claude Code with a simple prompt, commit and push, then verify it’s firing using the Meta Pixel Helper extension.

**How you’ll know it’s working:** Meta Pixel Helper shows your pixel ID and a PageView event on your live site. Events Manager shows the pixel status as Active.

---

## 7\. You Should Be Able to Build This Now

With what we just covered, you can:

- Set up the full Facebook Business infrastructure for any app you’re launching
- Use Claude to generate a structured, research-backed pre-launch ad campaign plan
- Install a tracking pixel on any site using Claude Code, no manual HTML editing
- Verify tracking is working before spending money on ads

### Check Yourself

- I have a Facebook Business account, Page, and Ad Account set up
- I’ve run the campaign planning prompt and have a structured campaign document
- I understand why Claude needs to ask clarifying questions before writing the plan
- The Meta Pixel is installed on my live site and verified with the Pixel Helper
- My campaign document includes UTM tag structure

✅

Ticking those boxes means you’re set up to actually run ads in the next lesson. Nice work getting here.

### If Something’s Not Working

⚠️

****Meta Pixel Helper shows “No pixel found”**  
****What’s happening:** The pixel code wasn’t added to the `<head>` of your page, or the deployment hasn’t propagated yet.  
****How to fix it:** Check that Claude Code committed and pushed successfully. Wait 1,2 minutes for Vercel to deploy, then hard-refresh the page (Cmd+Shift+R on Mac). If it still doesn’t show, ask Claude Code to verify where the pixel code was inserted and confirm it’s in the `<head>` of your root layout file.

⚠️

****Meta won’t let you create an Ad Account**  
****What’s happening:** This sometimes happens with new Facebook accounts that Meta considers unverified or low-trust.  
****How to fix it:** Make sure your personal Facebook profile is reasonably complete (profile photo, some activity) and that you’ve confirmed your email and phone number on the account. Give it 24 hours if Meta flags it for review, this is a platform trust issue, not a technical one.

---

## The Short Version

Here’s what I want you to walk away with:

- **The Facebook infrastructure prerequisites:** Page + Ad Account need to exist before you can run anything. Get them done early so they’re not blocking you when you’re ready to launch.
- **Claude can plan your entire campaign:** Feed it your research and docs, let it ask its clarifying questions, and it’ll produce a structured campaign plan that covers everything from audience targeting to UTM structure.
- **The Meta Pixel is non-negotiable:** Install it before you spend a dollar on ads. Without it, you’re running blind, no conversion tracking, no optimisation signal, no PostHog attribution.
- **What you can do now:** You’re one lesson away from having your first real ad live in the world.

---

## Quick Reference

### The Core Prompt Shape

```
Review the following in my folder:
- App - [App Name] - Market Research
- App - [App Name] - Summary

Design a Facebook campaign to drive initial early adopters to my page for the pre-launch.

Budget: $5–$10/day, capped at $[total]

Page: [your-url]

I need:
- The best ad structure
- Creatives
- Audience
- Relevant UTM tagging
- Metrics to track
- Success metrics

Review and do deep research on this, and before you write it, ask me all the relevant questions you have.

```

### UTM Parameter Reference

| Parameter     | What It Tracks      | Example              |
| ------------- | ------------------- | -------------------- |
| utm\_source   | Traffic source      | facebook             |
| utm\_medium   | Channel type        | paid\_social         |
| utm\_campaign | Campaign name       | prelaunch            |
| utm\_content  | Specific ad variant | audience1-creative-a |

### Meta Pixel Install Prompt

```
Setup meta pixel

[paste pixel code snippet here]

```

Then: `commit and push`

### Pixel Verification Checklist

- Meta Pixel Helper installed in Chrome
- Navigate to live site and refresh
- Extension shows pixel ID detected
- Extension shows PageView event firing
- Events Manager shows pixel status as Active

---

## Resources

### Tools Used

- [Meta Business Suite](https://business.facebook.com/?ref=deletosh.com)
- [Meta Events Manager](https://business.facebook.com/events%5Fmanager?ref=deletosh.com)where you create and manage your pixel
- [Meta Pixel Helper](https://chrome.google.com/webstore/detail/meta-pixel-helper?ref=deletosh.com)Chrome extension for verifying pixel installation

---

## Questions I Get Asked

**Q: Do I need a budget bigger than $5,10/day to get useful data?**

Honestly, no, not at this stage. The goal here isn’t to run a profit-generating ad campaign. It’s to put your idea in front of real people and see if they click. $5,10/day is enough to get a few hundred impressions and a handful of clicks. That’s enough to tell you whether your messaging resonates before you scale up.

**Q: Should I wait until the app is fully built before running ads?**

No, that’s the whole point of this lesson. By the time you’re ready to ship, you want to have an audience already waiting. Building in public, running small pre-launch campaigns, collecting beta signups, all of that means launch day isn’t just you shouting into the void.

**Q: The GTM doc I wrote in Module 2 says don’t run Meta ads. Should I follow that?**

The GTM doc was written for the full launch strategy, it’s arguing against Meta as a primary acquisition channel at scale because the economics don’t work at low budget long-term. This is different. This is a pre-launch experiment at $5/day to gather data. Those are two different things. Use the GTM plan as your north star for launch, and use this lesson as a validation step before you get there.

**Q: How do I know I’m ready for the next lesson?**

If you’ve got the pixel verified and Claude has produced a campaign plan for your app, you’re ready. The next lesson is actually building and launching the ads.

---

## 💬 Stuck? Come Talk to Us

💡

If something’s not clicking or you want to share what you’ve built, come find us in Discord.  
****The Product Path community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community’s active and I check in there too.

---

## Glossary

**Meta Pixel:** A small JavaScript snippet that you add to your website’s `<head>` tag. It fires events (like PageView) back to Facebook whenever someone visits your site, enabling ad conversion tracking and audience building. *(first comes up in Module 4, Lesson 7)*

**UTM parameters:** Tags appended to a URL that tell your analytics tool (PostHog, Google Analytics) where a visitor came from. Essential for attributing signups to specific ads. *(we use UTM tagging throughout the course, first discussed in Module 2, Lesson 6 - GTM Document)*

**Meta Pixel Helper:** A free Chrome extension from Meta that lets you verify a pixel is installed correctly on any page. Shows which pixel IDs are present and which events are firing. *(introduced in Module 4, Lesson 7)*

**Campaign brief:** The strategic document Claude produces in this lesson, not the final ad copy, but the plan that governs audience targeting, creative direction, budget structure, and success metrics. *(introduced in Module 4, Lesson 7)*

**Co-work (Claude):** The Claude Desktop feature that gives Claude access to a folder on your local machine, so it can read your documents and write output directly into your notes. *(first introduced in Module 2, Lesson 3 - Generating the Technical Document)*
### Module 4, Lesson 6: Bypass Ad Blockers with PostHog's Reverse Proxy
URL: https://deletosh.com/courses/product-path/04-06-bypass-ad-blockers/
Last updated: 2026-07-16T15:33:56.000Z
## How do you stop ad blockers from breaking PostHog analytics?

You stop ad blockers from dropping your analytics by routing PostHog through a reverse proxy on your own domain, so tracking requests no longer look like they are going to PostHog and get blocked.

You enable PostHog's managed proxy feature with your domain's DNS on Cloudflare, update the PostHog API host in your codebase to the proxy endpoint, and deploy the change. This matters because in tech audiences 30 to 40 percent of visitors run ad blockers, and without the proxy those people never appear in your data at all.

**The short version: you route PostHog through a reverse proxy on your own domain, so ad blockers no longer drop your tracking and your conversion data stays complete. Clean data is what makes every later decision trustworthy. The full proxy setup is inside The Product Path.**

In this lesson, I’m picking up directly from where we left PostHog. Analytics is installed and working, but right now it only captures visitors who *don’t* have an ad blocker. This lesson fixes that.

---

## Before We Start

Here’s what I’d expect you to have in place before this lesson:

**From previous lessons:**

- PostHog is installed and capturing events on your live landing page, you did this in Module 4, Lesson 5
- Your domain is on Cloudflare (or you can set it up there), this is what enables the automatic proxy configuration
- The GitHub → Vercel deployment pipeline is working, push to GitHub, Vercel deploys (Module 4, Lesson 3)
- Claude Code is installed and running in your WebStorm terminal (Module 3, Lesson 3)

**Tools / setup you’ll need:**

- WebStorm (or VS Code) with Claude Code running in the terminal
- A PostHog account, you set this up in Module 4, Lesson 5
- Your domain’s DNS managed by Cloudflare, this is what makes the automatic proxy setup work

**By the end of this lesson, you’ll:**

- Understand why ad blockers silently break your analytics
- Have PostHog’s reverse proxy set up through your own domain
- Know how to update the PostHog API host in your codebase and deploy the change
- Be able to verify the proxy is actually working, with an ad blocker enabled

---

## What Is This Lesson About?

**Duration:** \~7 minutes video + \~15 minutes practice **Skill Level:** Intermediate **What You’ll Build:** A reverse proxy configuration that routes PostHog tracking data through your own domain, making it invisible to ad blockers.

This is a short lesson but an important one. Most people skip it and then wonder why their analytics don’t add up. I want you to have this fixed before you start driving traffic, because once visitors start coming, you want to know you’re capturing all of them, not just the ones without ad blockers installed.

---

## Watch the Lesson

<iframe src=“[https://iframe.mediadelivery.net/embed/605189/c38df7c9,7267,4bed-a22a-f1301d70551f](https://iframe.mediadelivery.net/embed/605189/c38df7c9-7267-4bed-a22a-f1301d70551f?ref=deletosh.com)” allow=“autoplay; fullscreen; picture-in-picture” allowfullscreen loading=“lazy” style=“width:100%; aspect-ratio:16/9; border:none; border-radius:8px;”>

---

ℹ️

****How I’d suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section, pausing the video at the timestamps I’ve noted. After that, this guide is your reference, you shouldn’t need to rewatch to look something up.

---

## What We’re Covering

Here’s what I’m walking you through in this lesson and why it matters:

- **The ad blocker problem**: why a significant chunk of your visitors are invisible to PostHog right now
- **How a reverse proxy fixes it**: routing analytics traffic through your own domain so it doesn’t look like PostHog
- **Setting up the proxy in PostHog**: using PostHog’s managed proxy feature with Cloudflare
- **Updating your codebase**: one config change to tell PostHog to use your proxy endpoint
- **Verifying it works**: testing with an ad blocker actually enabled

---

## 1\. The Problem: Ad Blockers Kill Your Analytics *(\~0:00)*

At this point your PostHog setup is live. If you go into your project and hit Activities, then refresh your landing page, you should see events coming in, pageviews, clicks, whatever you’ve got set up.

But here’s the thing: that only works if the person visiting your page *doesn’t* have an ad blocker running. And a lot of people do. In tech audiences especially, it’s not unusual for 30,40% of visitors to be blocking trackers. On mobile, particularly on iPhone, where content blocking is on by default in many configurations, it’s even higher.

Those visitors don’t show up in your analytics at all. Not as bounces, not as low-engagement sessions, they’re just not there. Which means you’re making decisions based on a partial picture.

PostHog has a built-in solution for this: a reverse proxy. Instead of your page sending tracking data directly to `app.posthog.com`which ad blockers recognise and block, you route it through a subdomain on your own domain. From the browser’s perspective, it looks like data going to your own site. Ad blockers can’t distinguish that from regular network traffic.

---

## 2\. How the Reverse Proxy Works

### 2.1 The Core Idea

Right now, your PostHog script sends events to PostHog’s servers. The URL it hits, `app.posthog.com`is on every ad blocker’s list. So the blocker intercepts it and drops the request.

With the reverse proxy, you set up a subdomain on your domain, something like `g.yourdomain.com`that silently forwards all that traffic to PostHog on the backend. Your visitor’s browser sends data to `g.yourdomain.com`. Your server (Cloudflare, in this case) receives it and passes it along to PostHog. The visitor’s ad blocker sees a request to your own domain and lets it through.

The key thing PostHog tells you when setting this up: **don’t use anything that makes it obvious it’s an analytics proxy.** Don’t call the subdomain `analytics.yourdomain.com` or `tracking.yourdomain.com`. Use something generic, `g`, `t`, `a`, whatever. I used `g.noturo.app` in the lesson. It looks like any other request to my domain.

### 2.2 Why Cloudflare Makes This Easy

PostHog’s managed proxy feature integrates directly with Cloudflare. Instead of manually configuring DNS records and worker scripts yourself, PostHog can connect to your Cloudflare account and handle the configuration automatically. That’s what we’re using here.

If your domain isn’t on Cloudflare, you can still set up a reverse proxy, PostHog has documentation on doing it manually, but the automatic setup I’m showing only works when Cloudflare manages your DNS.

---

## 3\. Set Up the Reverse Proxy in PostHog *(\~0:50)*

### 3.1 Find the Proxy Settings

In your PostHog dashboard, look for the reverse proxy option. It’s typically under your project settings. You’re looking for something called **Managed Proxy** or **Reverse Proxy**: it may be labelled as beta, which is fine.

Click **Add** or **Set Up Reverse Proxy**.

### 3.2 Choose Your Subdomain

PostHog will ask you for a domain. This is the subdomain you want to use as your proxy endpoint.

Enter something generic. I used `g.nurturo.app`. The format is:

```
[something-generic].[your-domain].[tld]

```

Don’t use `posthog`, `analytics`, `tracking`, or anything that signals what it’s doing. Keep it short and ambiguous.

⚠️

PostHog explicitly warns you about this: use a generic subdomain name. Ad blockers maintain lists of known analytics proxies, so an obvious name defeats the purpose. Something like `g`, `t`, or `a` as the subdomain prefix is fine.

### 3.3 Configure via Cloudflare

Once you’ve entered your subdomain, PostHog will offer to configure it automatically. Click **Configure Automatically**.

It’ll ask you to authorise your Cloudflare account. Go through the authorisation flow, log into Cloudflare if prompted, approve the connection, and let PostHog do its thing.

This sets up the necessary DNS records and Cloudflare Worker configuration automatically. You don’t need to touch Cloudflare yourself.

ℹ️

The managed proxy feature was in beta when I recorded this. By the time you’re watching, it may be fully released, which might mean a slightly different UI. The concept is the same regardless: enter your subdomain, connect Cloudflare, let it configure itself.

Once it completes, your proxy endpoint is live. But we’re not done, your app is still pointing at PostHog’s servers directly. We need to update that.

---

## 4\. Update the PostHog API Host in Your Code *(\~2:55)*

### 4.1 What Needs to Change

When your landing page initialises PostHog, it sends data to an API host. Right now that’s pointing to PostHog’s servers. We need to change it to point to your new proxy subdomain.

The config change is small, it’s a single URL, but it has to be in your code and deployed before the proxy does anything useful.

### 4.2 The Prompt

Open Claude Code in your WebStorm terminal. Use this prompt:

```
Update my PostHog API host to https://g.yourdomain.app

```

Replace `g.yourdomain.app` with whatever subdomain you set up in step 3.2\. Claude will find the PostHog initialisation in your code and update the API host value.

If you’re comfortable finding it yourself, it’s usually in your main JS/TS file, look for the PostHog `init()` call. The option you’re changing is `api_host`. But letting Claude handle it is faster and you’re less likely to miss a second reference somewhere.

### 4.3 Commit and Deploy

Once Claude has made the change, tell it:

```
commit and push this

```

This commits the change and pushes to GitHub. Vercel picks it up automatically and deploys. Go to GitHub and look for the green checkmark next to the latest commit, that tells you the Vercel deployment succeeded.

---

## 5\. Verify It’s Actually Working *(\~3:50)*

This is the part I think is important to actually do, not just assume it’s working. Here’s how I tested it in the lesson.

### 5.1 Confirm Tracking Works Without an Ad Blocker First

Go to your PostHog dashboard and open the **Live** view under Activities. Then open your landing page in an incognito window and refresh a few times.

You should see events appearing in the Live view, something like “1 recently online” or “1 recently active recording.” That confirms PostHog is tracking without an ad blocker in play.

Close the incognito window.

### 5.2 Enable an Ad Blocker

Now enable an ad blocker. I use AdGuard, but whatever you have works. The point is to simulate what a real visitor with a blocker would look like.

With the blocker on, go back to PostHog Live view, then open your landing page and refresh.

Without the proxy, you’d see nothing. PostHog would show no activity from you. That’s the problem we just fixed.

### 5.3 Test With the Proxy Live

Make sure your Vercel deployment is complete (green checkmark on GitHub). Then repeat the test, ad blocker still on, refresh your landing page, watch the PostHog Live view.

You should now see events coming through, even with the blocker active. That’s the proxy working.

✅

If you’re seeing events in PostHog Live view with an ad blocker enabled, the proxy is working. You’re now capturing a much more complete picture of who’s visiting your page.

---

## 6\. Try It Yourself

### Exercise 1: Set Up the Proxy End-to-End

**What to do:** Follow sections 3, 4, and 5 above. Set up the managed proxy in PostHog, update the API host in your code via Claude Code, deploy, and verify with an ad blocker enabled.

**A nudge if you’re stuck:** The most common issue is the Cloudflare authorisation step. Make sure you’re logged into the right Cloudflare account, the one that manages the domain you’re using for your landing page. If PostHog can’t find your domain, check which account your DNS is under.

**How you’ll know it’s working:** PostHog Live view shows activity from your browser even when an ad blocker is enabled.

### Exercise 2: Check Your Network Requests

**What to do:** With your landing page open in Chrome, open DevTools (F12 / Cmd+Option+I), go to the Network tab, and filter by your proxy subdomain (e.g. `g.noturo.app`). Refresh the page.

**What you’re looking for:** Requests going to your subdomain, not `app.posthog.com`. If you see them, the proxy redirect is happening client-side too.

**What this is practising:** Understanding what the proxy actually does at the network level. Useful for debugging if something stops working later.

---

## 7\. You Should Be Able to Do This Now

Here’s what you can put together with what we just covered:

- Set up PostHog’s managed reverse proxy for any project using Cloudflare DNS
- Update a PostHog API host configuration using Claude Code
- Verify analytics integrity using PostHog’s Live view, with and without an ad blocker

### Check Yourself

- I’ve set up the PostHog managed proxy with a generic subdomain name
- Cloudflare authorisation went through and the proxy configured automatically
- I’ve updated the `api_host` in my PostHog init to point to my proxy subdomain
- I’ve committed and pushed the change, Vercel shows a green checkmark
- I’ve tested with an ad blocker enabled and can see events in PostHog Live view

✅

If those boxes are ticked, your analytics are solid. You’re capturing as complete a picture as you can get. Next up, we push traffic to this page.

### If Something’s Not Working

⚠️

****Cloudflare authorisation fails or PostHog can’t find your domain**  
****What’s happening:** PostHog is connecting to Cloudflare but can’t find the domain you entered. This usually means the domain is under a different Cloudflare account, or DNS isn’t managed by Cloudflare at all.  
****How to fix it:** Log into Cloudflare and confirm your domain is listed there under the account you authorised. If your domain is at a different registrar with its own DNS (not using Cloudflare nameservers), you’ll need to either move DNS to Cloudflare or follow PostHog’s manual proxy setup docs.

⚠️

****Events still not showing with ad blocker on after deploying**  
****What’s happening:** Either the deployment hasn’t completed yet, or the `api_host` in your code still points to PostHog’s servers.  
****How to fix it:** First, check GitHub, confirm the green checkmark is there. Then check your PostHog initialisation in your codebase and make sure `api_host` is set to your proxy subdomain (e.g. [https://g.yourdomain.app](https://g.yourdomain.app/?ref=deletosh.com)). If it still says [https://app.posthog.com](https://app.posthog.com/?ref=deletosh.com), the Claude Code update didn’t take or wasn’t committed.

⚠️

****Proxy subdomain is getting blocked**  
****What’s happening:** You may have used a name that’s on a common blocklist, like `analytics`, `tracking`, or `posthog` as the subdomain prefix.  
****How to fix it:** Go back into PostHog’s proxy settings and change the subdomain to something completely generic, `g`, `t`, `x`. Then update `api_host` in your code to match and redeploy.

---

## The Short Version

Here’s what I want you to walk away with:

- **Ad blockers silently drop PostHog requests**: without a proxy, you’re missing a significant slice of your traffic
- **The fix is a reverse proxy**: route analytics traffic through your own domain so it looks like a request to your own site
- **PostHog’s managed proxy makes it easy**: connect Cloudflare, pick a generic subdomain, done
- **One code change to wire it up**: update `api_host` in your PostHog init, commit, push, deploy
- **Always verify with a real ad blocker**: don’t assume it’s working; test it

---

## Quick Reference

### The Proxy Subdomain Format

```
g.[yourdomain].[tld]

```

Generic. Nothing that signals analytics or tracking. Short prefix is fine.

### The Code Change

In your PostHog `init()` call, update `api_host`:

```
posthog.init('phc_YOUR_KEY', {
  api_host: 'https://g.yourdomain.app',
  // ... other options
})

```

### The Claude Code Prompt

```
Update my PostHog API host to https://g.yourdomain.app

```

Then:

```
commit and push this

```

### How to Test

```
1. Open PostHog → Activities → Live view
2. Open your landing page in incognito → confirm events appear (no blocker)
3. Enable your ad blocker
4. Refresh your landing page
5. Check PostHog Live — you should still see events

```

---

## Resources

### Links & Docs

- [PostHog Reverse Proxy Documentation](https://posthog.com/docs/advanced/proxy?ref=deletosh.com)covers both managed (Cloudflare) and manual proxy setups
- [PostHog Managed Reverse Proxy (Cloudflare)](https://posthog.com/docs/advanced/proxy/cloudflare?ref=deletosh.com)specific to the Cloudflare automatic setup used in this lesson

### Tools Used

- [PostHog](https://posthog.com/?ref=deletosh.com)product analytics, installed in Module 4, Lesson 5
- [Cloudflare](https://cloudflare.com/?ref=deletosh.com)DNS and proxy infrastructure
- Claude Code, AI coding assistant, running in the WebStorm terminal
- [Vercel](https://vercel.com/?ref=deletosh.com)deployment pipeline, connected since Module 4, Lesson 3

---

## Questions I Get Asked

**Q: Do I really need to do this? How many people actually use ad blockers?**

More than you’d think, and it skews toward the exact demographic you’re probably targeting. Tech-savvy users, developers, and privacy-conscious people are much more likely to run ad blockers than the general public. If your product is aimed at that audience (and many of ours are), you could easily be missing 30,50% of visitors in your analytics without this fix.

**Q: My domain isn’t on Cloudflare, can I still do this?**

Yes, but you’ll need to do it manually. PostHog has documentation for setting up a reverse proxy with other providers like AWS CloudFront or NGINX. The automatic setup I showed only works with Cloudflare. If you want to keep things simple, the easiest path is to move your domain’s DNS to Cloudflare nameservers, it’s free and doesn’t change where your domain is registered, just where DNS is managed.

**Q: What if the proxy subdomain itself gets added to a blocklist eventually?**

It’s possible, but unlikely if you use a generic name. Ad blocker lists tend to target known tracking domains, not arbitrary subdomains on random people’s domains. And if it does happen, changing the subdomain and redeploying takes about 10 minutes.

**Q: Does this have any performance impact on my landing page?**

Negligible. The reverse proxy adds one hop in the network path for analytics requests, but those happen asynchronously in the background. They don’t block the page load or affect what your visitor sees.

**Q: How do I know I’m ready for the next lesson?**

Analytics works with ad blockers on. That’s the bar. When you can see events in PostHog Live view with AdGuard or uBlock or whatever you’re using enabled, you’re done here.

---

## 💬 Stuck? Come Talk to Us

💡

If something’s not clicking or you want to share what you’ve built, come find us in Discord.  
****The Product Path community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community’s active and I check in there too.

---

## Glossary

**Reverse proxy:** A server (or in this case, a Cloudflare Worker) that sits between your visitor’s browser and a third-party service. The browser sends requests to your domain; the proxy forwards them on to the real destination. From the browser’s perspective, it’s just talking to your site. *(introduced in Module 4, Lesson 6)*

**Managed proxy (PostHog):** PostHog’s built-in feature for automatically setting up a reverse proxy via Cloudflare. PostHog connects to your Cloudflare account and configures the DNS records and Worker routing on your behalf. *(introduced in Module 4, Lesson 6)*

**Ad blocker:** A browser extension or OS-level tool that blocks network requests to known tracking and advertising domains. Common examples include uBlock Origin, AdGuard, and Brave’s built-in shield. Blocks PostHog by default unless a reverse proxy is in place. *(introduced in Module 4, Lesson 6)*

**API host (PostHog):** The URL PostHog’s JavaScript SDK sends event data to. Defaults to `https://app.posthog.com`. Changed in this lesson to your proxy subdomain so requests are routed through your own domain instead. *(first introduced in Module 4, Lesson 5, Setup PostHog)*

**Cloudflare Worker:** A serverless function that runs at Cloudflare’s edge, used here to receive analytics requests from your subdomain and forward them to PostHog. Set up automatically by PostHog’s managed proxy feature. *(introduced in Module 4, Lesson 6)*
### Module 4, Lesson 5: Setup PostHog Analytics
URL: https://deletosh.com/courses/product-path/04-05-setup-posthog-analytics/
Last updated: 2026-07-16T15:33:54.000Z
## What is PostHog and how do you set it up?

PostHog is a product analytics platform that captures event-based data on what visitors do on your page: scrolling, button clicks, pricing interactions, and email signups.

You set it up by creating a free PostHog account, grabbing your project token, and handing it to Claude Code with a single prompt that installs PostHog and wires up event tracking, then commits and deploys the change through your GitHub to Vercel pipeline. In this lesson it is the final step before driving traffic, because sending people to a page you cannot measure means deciding in the dark.

**The short version: you add PostHog to your landing page so you can capture real visitor behavior, events, and conversion from the very first visitor instead of guessing. Analytics is what turns your launch into learning. The full setup is inside The Product Path.**

In this lesson, I’m adding product analytics to the landing page using PostHog. This is the final setup step before we start driving traffic, because there’s no point sending people to a page if you can’t measure what’s working.

---

## Before We Start

Here’s what I’d expect you to have in place before this lesson:

**From previous lessons:**

- Your landing page is live on a custom domain, you completed this in [Module 4, Lesson 4](https://deletosh.com/courses/product-path/04-04-custom-domain-vercel/)
- The GitHub → Vercel pipeline is working, push to GitHub, Vercel deploys automatically ([Module 4, Lesson 3](https://deletosh.com/courses/product-path/04-03-connect-vercel/))
- Kit (ConvertKit) integration is live, email signups land in your subscriber list ([Module 4, Lesson 2](https://deletosh.com/courses/product-path/04-02-connect-convertkit/))
- Claude Code is installed and running in your WebStorm terminal ([Module 3, Lesson 3](https://deletosh.com/courses/product-path/04-03-connect-vercel/))

**Tools / setup you’ll need:**

- WebStorm (or VS Code)
- Claude Code running in the WebStorm terminal
- A PostHog account, go to [posthog.com](https://posthog.com/?ref=deletosh.com) and sign up (free tier is more than enough)

**By the end of this lesson, you’ll:**

- Understand why product analytics matters before you drive traffic
- Have PostHog installed on your landing page and tracking key events
- Know how to use Claude Code to handle the entire installation with a single prompt
- Have your changes committed and deployed live via the GitHub → Vercel pipeline

---

## What Is This Lesson About?

**Duration:** \~8 minutes video + \~15 minutes practice **Skill Level:** Intermediate **What You’ll Build:** A PostHog integration on your landing page that tracks key user events, scrolling, button clicks, pricing interactions, and email signups.

This is one of those lessons where the actual work is fast but what it unlocks is huge. We’re adding the ability to see what people do on our page, which buttons they click, where they drop off, what’s converting. Without this, you’re flying blind when traffic starts coming in.

---

## Watch the Lesson

---

ℹ️

****How I’d suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section, pausing the video at the timestamps I’ve noted. After that, this guide is your reference, you shouldn’t need to rewatch to look something up.

---

## What We’re Covering

Here’s what I’m walking you through in this lesson and why it matters if you’re trying to ship real things:

- **Why analytics before traffic**: you don’t send people to a page you can’t measure
- **What PostHog is**: a product analytics tool that tracks user events on your page
- **The prompt pattern**: how to get Claude Code to research, ask questions, and install PostHog in one go
- **Getting your project token**: where to find it in PostHog and how to hand it to Claude
- **Commit and deploy**: pushing the changes live through the pipeline we already set up

---

## 1\. Why Analytics Before Traffic *(\~0:00)*

At this point we have our landing page set up. It’s live, it’s on a proper URL, and people can visit it. So what’s left before we start driving traffic?

Measurement.

When people come to our page, we want to know: are they scrolling down? Are they clicking buttons? If they click a button, where does it go, or where do they leave? Are they interacting with the pricing section? Are they actually signing up, or are they bouncing?

Pretty much, we’re trying to gather product analytics. That’s what this lesson is about.

This is the final step before you actually start sending people here. Because if you drive traffic without analytics in place, you have no idea what’s working and what isn’t. You’re making decisions in the dark.

🔥

Don’t skip this step. It’s tempting to start sharing your link the moment the page goes live, but set up tracking first. Even a few days of data before you optimise anything will give you a baseline to compare against.

---

## 2\. What Is PostHog?

### 2.1 The Tool

The product we’re using to track analytics in this course is called [PostHog](https://posthog.com/?ref=deletosh.com). It’s a very popular product analytics platform. Even if you’re not familiar with it, don’t worry, as we go through it, you’ll see what we’re getting.

PostHog gives you event-based analytics: it tracks what users do on your page (clicks, scrolls, pageviews) and lets you see that data in dashboards. It also offers session replay, feature flags, and A/B testing, but for our landing page, we’re focused on the core analytics.

The free tier is generous, you get 1 million events per month, which is way more than a pre-launch landing page will generate. No credit card required.

### 2.2 What We’re Tracking

For a landing page like ours, the key events we care about are:

- **Page views**: how many people are actually visiting
- **Scroll depth**: are people reading the whole page or bouncing early?
- **Button clicks**: which CTAs are getting engagement?
- **Pricing interaction**: are people looking at the pricing section? This matters because we’re using the landing page as a pre-launch test, and knowing which pricing tier gets more attention tells us what’s converting better
- **Email signups**: the main conversion event, tied to our Kit integration from Module 4, Lesson 2

### 2.3 How This Connects to Module 4, Lesson 2: Connect to ConvertKit

In Module 4, Lesson 2, we set up Kit for email capture. In this lesson, I also told Claude that we’re already using Kit and asked it to capture user properties, linking the analytics user to the email subscriber, so that eventually, when people convert, we can do analytics on those users too. The two tools work together: Kit captures the lead, PostHog tells you what they did before and after signing up.

---

## 3\. Sign Up for PostHog *(\~0:50)*

### 3.1 Create Your Account

Head to [posthog.com](https://posthog.com/?ref=deletosh.com) and click **Get Started**. You’ll get a signup screen, go ahead and complete the registration.

During onboarding, PostHog will ask you a few things: your company, what you’re building, what you want to do. I just left it as **Product Analytics** and clicked “Let’s Go.”

### 3.2 Stop at the Install Screen

Here’s the key thing: when you get to the install screen, the one that shows you code snippets and SDK options, just stop. Don’t manually install anything.

We’re going to let Claude Code handle the installation. That’s the whole point of how we work in this course.

💡

Leave the PostHog tab open, you’ll need to come back for your project token in a moment. But don’t try to follow their manual install instructions. Claude Code will do this for us.

---

## 4\. Let Claude Code Install PostHog *(\~1:40)*

### 4.1 The Prompt

Jump back into WebStorm where you have Claude Code running. Here’s the prompt I used:

```
I will want to track key events on my landing page with PostHog, research the key events I need and install setup PostHog.
When done give me the setup steps.
Before you do this, ask me all the questions you need.

```

This is the same pattern we used in Module 4, Lesson 2 with Kit, tell Claude what you want, ask it to do the research, and critically, tell it to ask you questions first before it starts making changes.

ℹ️

When you paste a prompt into Claude Code, it doesn’t always show you the full thing in the interface. That’s fine, it still processes the whole prompt. I showed the full prompt text separately in the video so you could see exactly what I typed.

### 4.2 Claude’s Questions

Claude came back and asked me a few clarifying questions. The exact questions you get might differ from mine, that’s normal. Claude adapts based on your project context.

Here’s how I answered mine:

1. **Is PostHog already set up?**No, I want it installed fresh. I’m using the API (cloud-hosted, not self-hosted). You’ll probably be using this option too.
2. **What’s the main conversion goal?**Email signup. That’s our primary event.
3. **Do you want to track pricing interaction?**Yes. Since we’re using this landing page as a pre-launch test, I want to know which pricing tier gets more attention. That data tells me what’s converting better.
4. **Privacy and compliance (GDPR/CCPA)?**PostHog uses cookies to track users, and normally you’d need a cookie consent banner for compliance. But since this is a pre-launch page, I’m comfortable keeping it loose for now. This is something you’d want to tighten up before a full launch.
5. **Existing tools, are you using Kit?**Yes, we are. I also told Claude I want it to capture user properties and link the analytics user to the email subscriber if possible, so we can do analytics on converted users down the line.

Once I answered those questions, I let Claude do its thing.

### 4.3 The API Key

Claude started working and mentioned it needed my PostHog project key. It used a placeholder for now and kept going, it doesn’t need to stop for that.

While Claude was running, I went back to PostHog, and here’s where you grab your token:

1. Go to your PostHog dashboard
2. Find your **Project API Key** (sometimes called the project token)
3. Click **Copy**

Then back in Claude Code, I just said: “Here is my API key” and pasted it in. Claude picked it up and continued, it figured out where to put it without stopping.

⚠️

****Don’t confuse the Project API Key with a personal API key.** The project key is the one you need, it’s scoped to your PostHog project and is what the JavaScript SDK uses to send events. You’ll find it in your PostHog project settings.

---

## 5\. Commit and Deploy *(\~5:40)*

### 5.1 Push to GitHub

Once Claude finished the installation, everything was still only on my local machine. To get it live, I told Claude Code:

```
commit and push this

```

That’s it. Remember, we set up the GitHub connection earlier in the course. Claude Code commits the changes and pushes them to GitHub.

### 5.2 Vercel Auto-Deploys

When we push to GitHub, Vercel picks it up automatically, that’s the pipeline we built in Module 4, Lesson 3\. If you go to your project on GitHub, you should see a green checkmark next to the latest commit. Click it, and it’ll tell you the Vercel deployment was completed.

So the flow is: Claude Code commits → pushes to GitHub → GitHub triggers Vercel → Vercel deploys → your live page is updated.

### 5.3 Nothing Visible Changes

If you go to your landing page and refresh, you won’t see anything different. That’s expected, PostHog runs in the background. There’s no visible UI change on your page. The tracking is invisible to visitors.

---

## 6\. Finish PostHog Onboarding *(\~6:50)*

### 6.1 Complete the Setup Wizard

Now go back to that PostHog install screen we paused on earlier. Since we already installed PostHog via Claude Code, we don’t need to follow their manual instructions.

Here’s what to do:

1. On the SDK selection screen, select **All** or **Web** (you should see JS listed)
2. Click **Skip Installation**: we already handled this
3. **Autocapture**: leave the defaults as they are. PostHog’s autocapture tracks clicks and pageviews automatically
4. **Session Replay**I enabled this. Why not? It lets you watch recordings of real user sessions on your page
5. Skip through the rest, stick to the **free plan**, don’t invite anyone, and click **Finish**

### 6.2 Verify Events Are Coming In

After finishing the wizard, go back to your live landing page and do a few actions, scroll around, click some buttons, interact with the page.

Then check your PostHog dashboard. You should start seeing events appear. If PostHog was showing “waiting for events” before, it should now be picking up your activity.

✅

If you see events appearing in your PostHog dashboard after interacting with your page, you’re done. PostHog is installed and tracking.

---

## 7\. Try It Yourself

### Exercise 1: Install PostHog on Your Landing Page

**What to do:** Follow the steps above, sign up for PostHog, grab your project token, use the prompt in Claude Code, answer Claude’s questions based on your project, then commit and push.

**A nudge if you’re stuck:** The most common issue is forgetting to give Claude your project API key. If Claude used a placeholder, make sure you paste your real key before committing. Check your project code for `phc_` followed by a string, that’s what a PostHog project key looks like.

**How you’ll know it’s working:** Go to your live landing page, click around for 30 seconds, then check your PostHog dashboard. You should see events, pageviews, clicks, maybe custom events Claude set up. If PostHog shows “waiting for events,” your key might be wrong or the deployment hasn’t gone through yet.

### Exercise 2: Explore the PostHog Dashboard

**What to do:** Spend 10 minutes clicking around PostHog. Look at the event feed, check out session replay if you enabled it, and find where your custom events show up.

**What this is practising:** Familiarity. You don’t need to master PostHog right now, but knowing where things live in the dashboard will matter when you start analysing traffic later.

---

## 8\. You Should Be Able to Do This Now

Here’s what you can do with what we just covered:

- Install PostHog on any web project using Claude Code
- Use the “ask me questions first” prompt pattern to get Claude to gather context before making changes
- Find and copy your PostHog project token
- Push changes live through the GitHub → Vercel pipeline

### Check Yourself

- I have a PostHog account on the free tier
- PostHog is installed on my landing page (via Claude Code)
- My project API key is in the code (not a placeholder)
- I’ve committed and pushed the changes to GitHub
- Vercel has deployed the update (green checkmark on GitHub)
- I can see events in my PostHog dashboard after visiting my live page

✅

If you’re ticking those boxes, analytics is live. You’re ready to start driving traffic, or move on to the next lesson where we handle ad blockers.

### If Something’s Not Working

⚠️

****PostHog dashboard shows “waiting for events” after deploying**  
****What’s happening:** Either the project API key is wrong, the deployment hasn’t completed, or there’s a code issue with the PostHog initialisation.  
****How to fix it:** First, check Vercel, make sure the deployment is complete (green checkmark on GitHub). Then open your browser’s developer console on your live page and look for any PostHog-related errors. Finally, check your code for the PostHog initialisation and confirm the API key starts with `phc_` and matches what’s in your PostHog project settings.

⚠️

****Claude Code used a placeholder key and you forgot to replace it**  
****What’s happening:** Claude sometimes uses a placeholder like `YOUR_POSTHOG_KEY` if you didn’t provide the real key during the session.  
****How to fix it:** Search your project files for “YOUR\_POSTHOG\_KEY” or any placeholder text. Replace it with your real project token from PostHog, then commit and push again.

⚠️

****Events show up locally but not on the live site**  
****What’s happening:** You probably tested locally but haven’t pushed the changes yet.  
****How to fix it:** Run `commit and push this` in Claude Code. Then wait for Vercel to deploy. Check GitHub for the green checkmark.

---

## The Short Version

Here’s what I want you to walk away with:

- **Set up analytics before you drive traffic**: you can’t optimise what you can’t measure
- **PostHog tracks what users do on your page**: clicks, scrolls, conversions, all of it, with a generous free tier
- **Claude Code handles the install**: use the “ask me questions first” prompt pattern, hand over your API key, and let it work
- **The deployment pipeline does the rest**: commit, push to GitHub, Vercel deploys automatically

---

## Quick Reference

### The Prompt

```
I will want to track key events on my landing page with PostHog, research the key events I need and install setup PostHog.
When done give me the setup steps.
Before you do this, ask me all the questions you need.

```

### Where to Find Your PostHog Project Token

```
PostHog Dashboard → Project Settings → Project API Key → Copy

```

The key will start with `phc_` followed by a long alphanumeric string.

### Deploy After Installing

```
commit and push this

```

This commits the PostHog changes and pushes to GitHub, which triggers Vercel to redeploy.

### Key Events for a Landing Page

```
Pageview            — someone visited
Scroll depth        — how far down they got
CTA button click    — which buttons are getting engagement
Pricing interaction — are people looking at pricing tiers?
Email signup        — the main conversion event

```

---

## Resources

### Links & Docs

- [PostHog](https://posthog.com/?ref=deletosh.com)the product analytics platform used in this lesson
- [PostHog JavaScript SDK Docs](https://posthog.com/docs/libraries/js?ref=deletosh.com)reference for the JS library Claude Code installs
- [PostHog Free Tier Details](https://posthog.com/pricing?ref=deletosh.com)1M events/month free, no credit card required

### Tools Used

- [PostHog](https://posthog.com/?ref=deletosh.com)product analytics
- Claude Code, AI coding assistant, running inside the WebStorm terminal
- WebStorm, IDE used throughout the course (VS Code works fine too)
- [Vercel](https://vercel.com/?ref=deletosh.com)deployment and hosting, connected since Module 4, Lesson 3

---

## Questions I Get Asked

**Q: Why PostHog and not Google Analytics?**

PostHog is designed for product analytics, tracking specific user actions and events, which is what we need for a landing page we’re testing. Google Analytics is more geared toward general website traffic and marketing attribution. PostHog’s free tier is also extremely generous, and it’s what we’ll use for the actual product later too, so starting here means one less migration.

**Q: Do I need a cookie consent banner?**

Technically, if you’re collecting data from users in the EU (GDPR) or California (CCPA), yes. PostHog uses cookies to track users. For a pre-launch page, I kept it loose, but if you’re driving significant traffic or your audience is in those regions, you’ll want to add a consent banner before a full launch. PostHog has built-in support for cookie-less tracking if you want to go that route later.

**Q: What if Claude Code asks me different questions than what you showed?**

That’s expected. Claude adapts to your specific project and context. The questions might be worded differently or focus on different areas. The key things to communicate are: you want PostHog installed (cloud, not self-hosted), your main conversion event is email signup, and whether you want to track pricing interactions. Answer honestly based on your project and Claude will figure out the rest.

**Q: Can I see session recordings of real users?**

Yes, if you enabled Session Replay during PostHog’s onboarding wizard, you’ll start seeing recordings once real traffic hits your page. It’s genuinely useful for seeing where people hesitate, what they skip, and where they drop off. The free tier includes 5,000 recordings per month.

**Q: How do I know I’m ready for the next lesson?**

If PostHog is installed, events are showing up in your dashboard, and the deployment is live, you’re good. The next lesson covers handling ad blockers, which can prevent PostHog from tracking some users.

---

## 💬 Stuck? Come Talk to Us

💡

If something’s not clicking or you want to share what you’ve built, come find us in Discord.  
****The Product Path community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community’s active and I check in there too.

---

## Glossary

**PostHog:** An open-source product analytics platform that tracks user events, clicks, pageviews, scrolls, custom events, and provides dashboards, funnels, session replay, and more. Free tier includes 1M events/month. *(introduced in Module 4, Lesson 5)*

**Product analytics:** The practice of tracking and analysing how users interact with your product or page. Different from general web analytics (like GA), product analytics focuses on specific user actions and conversion events. *(introduced in Module 4, Lesson 5)*

**Project API Key (PostHog):** A unique identifier for your PostHog project, used by the JavaScript SDK to send events to the correct dashboard. Starts with `phc_`. Found in your PostHog project settings. Not the same as a personal API key. *(introduced in Module 4, Lesson 5)*

**Autocapture:** A PostHog feature that automatically tracks clicks, pageviews, and other standard user interactions without you manually defining each event. Useful as a baseline, you can layer custom events on top. *(introduced in Module 4, Lesson 5)*

**Session Replay:** A PostHog feature that records real user sessions on your page, like watching a screen recording of what each visitor did. Useful for spotting UX issues and understanding drop-off points. Free tier includes 5,000 recordings/month. *(introduced in Module 4, Lesson 5)*

**Event (analytics):** A single tracked action, like a pageview, button click, or form submission. PostHog records these and lets you analyse them in dashboards. The free tier covers 1M events per month. *(introduced in Module 4, Lesson 5)*
### Module 4, Lesson 4: Custom Domain to Vercel
URL: https://deletosh.com/courses/product-path/04-04-custom-domain-vercel/
Last updated: 2026-07-16T15:33:53.000Z
## How do you add a custom domain in Vercel?

You add a custom domain in Vercel by adding the domain inside your Vercel project dashboard, then creating a DNS record at your domain registrar that points the domain at Vercel's servers so requests route to your deployment.

Vercel handles the HTTPS certificate for you, and once DNS propagates your page runs on your own branded URL instead of a .vercel.app subdomain. In this lesson that swap is the finishing touch that makes the page read as a real product rather than a prototype.

**The short version: you point your domain at your Vercel deployment and configure DNS so your landing page runs on your own branded URL with HTTPS handled for you. A real domain is what makes the page look legitimate to visitors. The full DNS setup is inside The Product Path.**

## Before We Start

Here’s what I’d expect you to have in place before this lesson:

**From previous lessons:**

- Your landing page is live on Vercel, you have a working `.vercel.app` URL from Module 4, Lesson 3
- Your project is in a GitHub repo and Vercel is connected to it
- The Kit (ConvertKit) integration is working, emails land in your subscriber list

**Tools / setup you’ll need:**

- WebStorm (or VS Code)
- Access to your Vercel dashboard
- A domain name, either one you already own or one you’re buying now. I’ll walk through this in the lesson.
- Access to your domain registrar (wherever you bought the domain, Namecheap, GoDaddy, Google Domains, etc.)

**By the end of this lesson, you’ll:**

- Have a custom domain pointed at your Vercel deployment
- Understand what DNS records are and the basic change you need to make
- Have a proper, professional URL you can share with people, not `yourproject.vercel.app`

---

## What Is This Lesson About?

**Duration:** \~5 minutes video + \~20 minutes practice (DNS can take a little time to propagate) **Skill Level:** Intermediate **What You’ll Build:** A custom domain connected to your live Vercel deployment

This is the finishing touch. We’ve got a live page, we’ve got email capture working, but the URL still says `.vercel.app`. In this lesson we swap that out for a real domain. It’s a small change that makes a big difference in how the product is perceived.

---

## Watch the Lesson

---

ℹ️

****How I’d suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section, pausing the video at the timestamps I’ve noted. After that, this guide is your reference, you shouldn’t need to rewatch to look something up.

---

## What We’re Covering

Here’s what I’m walking you through in this lesson:

- **Why the `.vercel.app` URL isn’t your final address**: and why a custom domain matters for perception and trust
- **Getting a domain**: what to look for and where I buy mine
- **Adding the domain in Vercel**: the two or three clicks it takes inside the dashboard
- **Updating your DNS records**: the one change you need to make at your registrar
- **Verifying it’s live**: what to check and how long to expect it to take

---

## 1\. Let’s Set the Scene *(\~0:00)*

At this point, we’re going into what is, honestly, as exciting to me as it probably is to you. We’ve been building all this stuff out, and now we’re at the part where it goes fully live with a real address.

In the previous lessons, we built the landing page, connected email capture, and deployed to Vercel. When you open that `.vercel.app` link and share it with someone, it works, but it doesn’t look like a product yet. It looks like a prototype or a dev environment. A custom domain changes that.

The goal of the landing page, remember, is to get people to sign up for the waitlist. We’re driving traffic to it and getting people to say *I want to use this.* That’s harder to do when the URL reads `nurturo-landing-page-abc123.vercel.app`. People notice those things, even if they don’t consciously register why.

This is the step that makes the page feel like a real product you’re launching, not something you’re still tinkering with.

ℹ️

Even if you’re building a mobile app (not a web app), this still matters. Your landing page is the public face of your product before it ships. It needs a proper home on the internet.

---

## 2\. The Core Idea

### 2.1 What a Custom Domain Actually Is

When someone types `nurturo.app` into a browser, the internet needs to know which server to send them to. That routing is handled by DNS, Domain Name System. Think of it as a massive phonebook: “when someone asks for `nurturo.app`, send them to Vercel’s servers.”

Right now your site lives at Vercel’s servers, but the phonebook entry points to a Vercel subdomain, not your name. What we’re doing in this lesson is adding a new phonebook entry: “when someone asks for `nurturo.app`, send them to the same Vercel deployment.”

You do this by adding a DNS record at your domain registrar. That’s it. One record. Vercel handles everything else.

### 2.2 Why This Comes After Everything Else

We’ve deliberately left this until the end of the Build module because domain changes involve DNS propagation, a period of time (anywhere from a few minutes to 48 hours) where the new routing is spreading across the internet. There’s nothing to do during that window except wait.

By the time you do this, your page is already live and working. We’re just upgrading the address, not rebuilding the house.

### 2.3 How This Connects to Module 4, Lesson 3: Connect to Vercel

In Module 4, Lesson 3, we set up the GitHub → Vercel deployment pipeline. Your project is already live on Vercel, we’re not redeploying anything in this lesson. We’re just telling Vercel “this custom domain also belongs to this project,” and telling your domain registrar “send traffic for this domain to Vercel.”

---

## 3\. Get a Domain *(\~1:00)*

If you already have a domain for your product, skip this section. If not, here’s how I approach it.

### 3.1 Where to Buy

I use [Namecheap](https://namecheap.com/?ref=deletosh.com) for most domains. It’s straightforward, reasonably priced, and the DNS management interface is clear. Other good options are [Porkbun](https://porkbun.com/?ref=deletosh.com) (often has great first-year prices) or [Cloudflare Registrar](https://cloudflare.com/products/registrar/?ref=deletosh.com) (sells at cost, no markup). I’d avoid GoDaddy, the upsells are relentless and the UX is not great.

### 3.2 What to Look For

Keep it simple. For a landing page at this stage, you want:

- Short, easy to type, easy to say out loud
- Memorable, one word is better than three
- `.com` if you can, it carries more weight than people like to admit. If `.com` is taken, `.co` or `.io` or `app` are solid alternatives depending on your market

Don’t overthink this. You’re not naming your company, you’re giving the landing page a home. Pick something that makes sense and move on.

### 3.3 Register and Log In

Go to your registrar, search for your domain, purchase it. Once it’s in your account, you’ll need to access your **DNS settings**: that’s the panel where you manage your DNS records. In Namecheap, it’s under **Advanced DNS** on the domain management page.

Leave that tab open, you’ll be coming back to it shortly.

---

## 4\. Add the Domain in Vercel *(\~2:30)*

### 4.1 Go to Your Project in Vercel

Log into [vercel.com](https://vercel.com/?ref=deletosh.com) and open the project you deployed in Module 4, Lesson 3\. At the top of the project page, you’ll see a set of tabs, look for **Settings**.

Inside Settings, find **Domains** in the left sidebar.

### 4.2 Add Your Domain

Click **Add Domain**. Type in your domain, for example, `nurturo.app`. Click **Add**.

Vercel will immediately tell you what DNS records you need to set. It usually shows you one of two things:

- An **A record** pointing to Vercel’s IP address (for the root domain, `yournurturo.com`)
- A **CNAME record** pointing to `cname.vercel-dns.com` (for a `www` subdomain, `www.yournurturo.com`)

💡

Vercel will show you the exact values you need to copy. Don’t try to remember them, keep the Vercel tab open alongside your registrar tab so you can copy and paste directly.

Vercel will show a red or yellow status next to the domain, that’s expected. It means it hasn’t verified the DNS change yet. That changes once you update your records.

---

## 5\. Update Your DNS Records *(\~3:30)*

### 5.1 Go to Your Registrar’s DNS Settings

Switch to the tab where you have your registrar open. Navigate to your DNS management panel, in Namecheap, this is **Advanced DNS** on your domain page. In other registrars, it might be called “DNS Zone Editor” or just “DNS Settings.”

You’re looking for where you can add or edit **DNS records**.

### 5.2 Add the Records Vercel Gave You

Vercel will typically ask for two records:

**Record 1, Root domain (`@`)**

| Type | Host | Value       | TTL       |
| ---- | ---- | ----------- | --------- |
| A    | @    | 76.76.21.21 | Automatic |

**Record 2, www subdomain**

| Type  | Host | Value                                                                  | TTL       |
| ----- | ---- | ---------------------------------------------------------------------- | --------- |
| CNAME | www  | [cname.vercel-dns.com](https://cname.vercel-dns.com/?ref=deletosh.com) | Automatic |

⚠️

Copy the exact values from **your* Vercel dashboard, don’t copy the values from these notes. Vercel’s IP addresses and CNAME targets are correct as of when this was written, but always defer to what Vercel is currently telling you in the interface.

In Namecheap, to add a record: click **Add New Record**, set the type, fill in the host and value, and save. Do this for both records.

### 5.3 Remove Conflicting Records (If Any)

If there’s already an A record or CNAME for `@` or `www` pointing somewhere else (like a parking page), delete those first. You can’t have two A records for the same host pointing to different places, the old one will override or conflict with the new one.

---

## 6\. Wait for Propagation *(\~4:30)*

Once you’ve saved the DNS records, go back to Vercel. Refresh the Domains page for your project.

Vercel will start checking automatically. In most cases, especially with Namecheap, this happens within a few minutes. Sometimes it takes longer. DNS propagation is just the internet updating its phonebook entries, and some parts of the internet update faster than others.

When Vercel shows a green checkmark next to your domain, you’re done. Open a new browser tab, type your domain, and your landing page should appear.

✅

If your page loads at your custom domain, with HTTPS, that’s it. You’re live with a proper address.

ℹ️

Vercel automatically provisions an SSL certificate (HTTPS) for your custom domain once the DNS is verified. You don’t need to set that up manually, it just happens. Give it a few minutes after the domain goes green.

---

## 7\. Try It Yourself

### Exercise 1: Get the Domain Connected

**What to do:** If you don’t already have a domain, buy one. Then follow sections 4 and 5, add it in Vercel, copy the DNS records Vercel gives you, and enter them at your registrar.

**A nudge if you’re stuck:** The most common confusion is which record goes where. Remember: the A record is for the root domain (the `@` or blank host field), and the CNAME is for `www`. Vercel will tell you both.

**How you’ll know it’s working:** Vercel shows a green checkmark next to your domain, and typing the domain in the browser loads your landing page.

### Exercise 2: Share the Link

**What to do:** Once your domain is live, share it with at least one real person. Not just open it yourself, send the link to someone.

**What this is practising:** Validation. The point of this whole module was to get something people can visit. Sharing it is the final step in making it real, not just technically live.

---

## 8\. You Should Be Able to Build This Now

Here’s what you can do with what we just covered:

- Connect any custom domain to a Vercel deployment
- Add A and CNAME DNS records at any major registrar
- Understand what DNS propagation is and how long to expect it to take

### Check Yourself

- I have a domain registered and I know how to access its DNS settings
- I’ve added the domain in my Vercel project under Settings → Domains
- I’ve added the A record and CNAME record at my registrar exactly as Vercel specified
- Vercel shows a green checkmark next to my domain
- I’ve confirmed the page loads at my custom domain (with HTTPS)

✅

If you’re ticking those boxes, you’re done with the landing page build. You’ve gone from nothing to a live, email-capturing, properly-addressed product page. That’s real.

### If Something’s Not Working

⚠️

****Vercel still showing red after 30+ minutes**  
****What’s happening:** Either the DNS records haven’t propagated yet, or the values were entered incorrectly.  
****How to fix it:** Double-check the records in your registrar, make sure the host and value fields match exactly what Vercel specified. One typo in the CNAME value will cause this. If everything looks right, just wait, some registrars take a few hours.

⚠️

****Domain loads but shows a different page (or an old site)**  
****What’s happening:** There may be old DNS records or caching getting in the way.  
****How to fix it:** Check your registrar’s DNS settings and delete any A records or CNAMEs that aren’t the ones you added for Vercel. Then try a hard refresh in your browser (Shift+Ctrl+R on Windows, Shift+Command+R on Mac) or open the link in an incognito window.

⚠️

****HTTPS isn’t working, browser shows “Not Secure”**  
****What’s happening:** Vercel’s SSL certificate provisioning takes a few minutes after the domain goes green. It’s not instant.  
****How to fix it:** Wait 5,10 minutes after the domain verifies, then try again. If it’s still showing after an hour, check Vercel’s SSL settings in your project dashboard, sometimes you need to manually trigger a certificate refresh.

⚠️

****Conflicting existing A record, can’t add Vercel’s**  
****What’s happening:** Your registrar probably added a default A record pointing to a parking page when you registered the domain.  
****How to fix it:** Delete the existing A record for `@` first, then add Vercel’s. You can only have one A record per host pointing to one destination.

---

## The Short Version

Here’s what I want you to walk away with:

- **A `.vercel.app` URL is temporary**: it works, but it doesn’t signal “real product” to visitors
- **Custom domains work via DNS**: you add two records at your registrar, Vercel picks them up, and your domain starts routing to your deployment
- **Vercel handles HTTPS automatically**: once the domain verifies, the SSL certificate is provisioned for you
- **DNS propagation takes time**: usually minutes, sometimes hours. Not a bug, just how the internet works

---

## Quick Reference

### DNS Records to Add at Your Registrar

| Type  | Host | Value                                                                  | TTL       |
| ----- | ---- | ---------------------------------------------------------------------- | --------- |
| A     | @    | *(copy from Vercel — usually 76.76.21.21)*                             | Automatic |
| CNAME | www  | [cname.vercel-dns.com](https://cname.vercel-dns.com/?ref=deletosh.com) | Automatic |

*(Always use the exact values Vercel gives you, don’t rely on this table alone)*

### Where to Find Things in Vercel

```
Your project → Settings (top nav) → Domains (left sidebar) → Add Domain

```

### DNS Settings in Common Registrars

```
Namecheap   → Domain List → Manage → Advanced DNS
Porkbun     → Account → Domain Management → DNS Records
GoDaddy     → My Products → DNS → Manage Zones
Cloudflare  → DNS → Records

```

### Checking Propagation

Open a terminal and run:

```
dig yourdomainname.com

```

You should see Vercel’s IP address (`76.76.21.21`) in the A record section. If you see something else, propagation hasn’t reached your network yet. Give it more time.

---

## Resources

### Links & Docs

- [Vercel Custom Domains Documentation](https://vercel.com/docs/projects/domains?ref=deletosh.com)the official guide if you want to go deeper
- [Namecheap](https://namecheap.com/?ref=deletosh.com)registrar I use in the course
- [Porkbun](https://porkbun.com/?ref=deletosh.com)another solid option, often cheaper for first year
- [Cloudflare Registrar](https://cloudflare.com/products/registrar/?ref=deletosh.com)sells domains at cost, no markup
- [DNS Checker](https://dnschecker.org/?ref=deletosh.com)useful tool for checking propagation across different locations worldwide

### Tools Used

- [Vercel](https://vercel.com/?ref=deletosh.com)deployment and hosting platform, used since Module 4, Lesson 3
- WebStorm, IDE used throughout the course (VS Code works fine too)

---

## Questions I Get Asked

**Q: Do I really need a `.com`? What about `.io` or `.co`?**

`.com` carries more instinctive trust, especially outside the tech world. But `.io` is well understood in the startup space and `.co` is clean and recognisable. If `.com` is taken and you can get `.co` or `.io`, that’s a fine call. What I’d avoid is anything obscure, `.xyz`, `.biz`, `.info`. They read as low-effort to most people.

**Q: Can I use a domain I already have that’s pointing somewhere else?**

Yes, but you’ll need to update the DNS records, which will redirect the domain to Vercel. If that domain is actively being used for something else (like an existing website), you’ll take that down by changing the records. Make sure you understand what you’re pointing away from before you do this.

**Q: Do I need both the A record and the CNAME, or just one?**

Both. The A record handles the root domain (`yournurturo.com`), and the CNAME handles the `www` version (`www.yournurturo.com`). Vercel will redirect one to the other automatically, but you need both records for it to verify and provision the certificate correctly.

**Q: How long does DNS propagation actually take?**

In my experience with Namecheap → Vercel, it’s usually 5,15 minutes. The theoretical maximum is 48 hours (that’s the TTL), but in practice it’s rarely that long. If you’re still seeing red in Vercel after an hour, recheck the record values, something is usually off.

**Q: What happens to my `.vercel.app` URL once I add a custom domain?**

It still works. Vercel doesn’t disable it. You’ll have two addresses pointing to the same deployment, the original Vercel subdomain and your new custom domain. Some people keep the Vercel URL as a backup; some just ignore it. Either way, it’s not going anywhere unless you explicitly remove it.

**Q: How do I know I’m ready to move on?**

Your custom domain loads your landing page with HTTPS in the browser. That’s the bar. When that’s working, you’re done with this lesson.

---

## 💬 Stuck? Come Talk to Us

💡

If something’s not clicking or you want to share what you’ve built, come find us in Discord.  
****The Product Path community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community’s active and I check in there too.

---

## Glossary

**Custom domain:** A domain name you own, like `yournurturo.com`as opposed to the free subdomain Vercel assigns to your project (`something.vercel.app`). Connected to your Vercel deployment via DNS records. *(introduced in Module 4, Lesson 4)*

**DNS (Domain Name System):** The internet’s phonebook. When someone types a domain name into a browser, DNS translates it into the IP address of the server that should respond. *(introduced in Module 4, Lesson 4)*

**A record:** A type of DNS record that maps a domain name to an IP address. Used here to point your root domain (`@`) at Vercel’s servers. *(introduced in Module 4, Lesson 4)*

**CNAME record:** A type of DNS record that maps one domain name to another. Used here to point `www.yournurturo.com` at `cname.vercel-dns.com`, which Vercel then resolves to the right deployment. *(introduced in Module 4, Lesson 4)*

**DNS propagation:** The time it takes for a DNS record change to spread across the internet’s network of servers. Usually minutes, can take up to 48 hours. Nothing you can do to speed it up, just wait. *(introduced in Module 4, Lesson 4)*

**Domain registrar:** The company where you bought your domain name. Namecheap, Porkbun, Cloudflare, and GoDaddy are examples. Your registrar is where you go to manage DNS records. *(introduced in Module 4, Lesson 4)*

**SSL certificate / HTTPS:** The encryption layer that makes your site load with `https://` instead of `http://`. Vercel provisions this automatically for custom domains once DNS is verified. The padlock icon in the browser address bar means it’s working. *(introduced in Module 4, Lesson 4)*

**Vercel subdomain:** The free URL Vercel gives every deployment, something like `your-project.vercel.app`. Works, but doesn’t look like a finished product. Replaced in this lesson with a proper custom domain. *(first introduced in* [*Module 4, Lesson 3*](https://deletosh.com/courses/product-path/04-03-connect-vercel/)*Connect to Vercel)*
### Module 4, Lesson 3: Connect to Vercel
URL: https://deletosh.com/courses/product-path/04-03-connect-vercel/
Last updated: 2026-07-16T15:33:51.000Z
## How do you deploy a landing page to Vercel?

You deploy a landing page to Vercel by first pushing your project to a GitHub repository, then signing up for Vercel with your GitHub login and connecting it to that repo, which gives you a live public URL.

From then on Vercel redeploys automatically every time you push to GitHub, so your site stays current without manual uploads. Both GitHub and Vercel are free at this scale, and in this lesson you go from a project running only on localhost to a page anyone on the internet can visit.

**The short version: you connect your project to Vercel so it builds and deploys automatically, going live on every push instead of through manual uploads. Continuous deploys are what keep your page always current. The full setup is inside The Product Path.**

## Before We Start

Here’s what I’d expect you to have in place before this lesson:

**From previous lessons:**

- Your landing page (`index.html`) is complete and working locally, Module 4, Lesson 1
- The Kit integration is live and tested, Module 4, Lesson 2
- You’re comfortable with WebStorm’s terminal, Module 3, Lesson 1

**Tools / setup you’ll need:**

- WebStorm (or VS Code)
- A GitHub account, if you don’t have one yet, go to [github.com](https://github.com/?ref=deletosh.com) and sign up before starting this lesson
- A Vercel account, we’ll create this during the lesson using GitHub login, so you don’t need to pre-register

**By the end of this lesson, you’ll:**

- Have your project pushed to a GitHub repository
- Have Vercel connected to that GitHub repo and your page deployed
- Have a live, public URL that anyone on the internet can visit

---

## What Is This Lesson About?

**Duration:** \~8 minutes video + \~15 minutes practice **Skill Level:** Intermediate **What You’ll Build:** A publicly live deployment of your landing page via GitHub and Vercel

This is the moment it all becomes real. Up until now, everything we’ve been building has been running on your machine, nobody else can see it. In this lesson we push it to GitHub, connect it to Vercel, and get a live URL on the internet. It takes less time than you’d think.

---

## Watch the Lesson

---

ℹ️

****How I’d suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section, pausing the video at the timestamps I’ve noted. After that, this guide is your reference, you shouldn’t need to rewatch to look something up.

---

## What We’re Covering

Here’s what I’m walking you through in this lesson and why it matters:

- **Creating a GitHub repository**: where your project lives so Vercel can access it
- **Pushing your local project to GitHub**: getting all your files off your machine and into the repo
- **Signing up for Vercel and connecting GitHub**: one-click deployment setup
- **Deploying your site**: going from a GitHub repo to a live public URL
- **What comes next**: a teaser on what the Vercel URL looks like and why we’ll add a proper domain in the next lesson

---

## 1\. Let’s Set the Scene *(\~0:00)*

In the previous session, we connected our page to Kit, where we track and capture user emails. The landing page looks right, the CTA works, emails go into Kit when someone signs up. That’s all good.

Now we want to make the website publicly available to everyone. Right now it only runs on localhost, your machine. We need it on the actual internet.

To do that, we need two things: a place to store the code (GitHub), and a service that reads that code and hosts it as a website (Vercel). Both are free. Both take about five minutes to set up. Let’s do it.

---

## 2\. The Core Idea

### 2.1 GitHub: Where Your Code Lives

GitHub is where we store the project. Think of it as a cloud backup for your code, but more than that, it’s how Vercel knows what to deploy. Every time you push changes to GitHub, Vercel can pick them up automatically and redeploy your site. That’s the deployment loop we’re setting up here.

If you followed along in Module 1 or have done any git work before, you’ll already have a GitHub account. If not, go to [github.com](https://github.com/?ref=deletosh.com) and sign up before you continue.

### 2.2 Vercel: Where Your Site Lives

Vercel is a hosting platform. You point it at your GitHub repo, tell it which folder to deploy, and it makes your files available on a public URL. It handles all the infrastructure, the servers, the CDN, the HTTPS certificate, so you don’t have to.

The free tier is genuinely generous. You can host multiple projects, get automatic deploys on every push, and the performance is solid. For a landing page at this stage, you don’t need anything else.

### 2.3 Why This Order Matters

We’re pushing to GitHub first because Vercel connects *to* GitHub, not directly to your machine. Once the repo is there, Vercel can read it, deploy it, and watch for any future changes. That’s why git comes before Vercel, not the other way around.

---

## 3\. Step 1: Push Your Project to GitHub *(\~0:20)*

### 3.1 Create a New Repository

Go to [github.com](https://github.com/?ref=deletosh.com) and log in. At the top of the page, click the **+** button and select **New repository**.

Here’s how I fill this out:

- **Repository name:** Give it the same name as your project folder in WebStorm. Mine is `nurturo-landing-page`. Matching names keeps things clear.
- **Description:** Optional. I put something short like “Nurturo landing page”, it’s just for your own reference.
- **Visibility:** Set this to **Private** for now. Private means only you can see it. Public means anyone on GitHub can browse your code. You can always make it public later, but while you’re building, keep it private.
- **Initialise with a README:** Leave the defaults as-is. Don’t check this box, you already have files locally and we don’t want GitHub adding anything that’ll conflict.

Click **Create repository**.

### 3.2 Connect Your Local Project to GitHub

Once the repo is created, GitHub shows you two options for what to do next. You want the **first block**: the one that says “create a new repository on the command line.” There’s a copy button in the top right of that block. Copy all of it.

Now open WebStorm. If the terminal isn’t open, press `Alt+F12` (or `Command+E` on Mac and type “terminal”). Create a new terminal tab so you’re starting fresh, click the `+` icon in the terminal panel.

Paste the command block you copied from GitHub and hit enter.

⚠️

****Authentication errors on push?**  
If you get an error that says something like “authentication failed” or “password not supported,” try this: in GitHub, copy the ****SSH** version of the command instead of the HTTPS version (there’s a tab toggle at the top of the command block). If that still fails, run `rm -rf .git` in your terminal to clear any broken git state, then paste the command again from scratch. That usually sorts it out.

### 3.3 Verify the Files Are There

After the command runs, go back to GitHub and refresh the page for your new repository. You should now see your files, `index.html`, `README.md`, and everything else in the project.

The critical one to check is `index.html`. If it’s there, you’re good to move on. If it’s not there, only `README.md` is showing up, read the next section.

### 3.4 If Your Files Didn’t Push

This happened to me during recording, so I’ll walk you through the fix.

Sometimes the initial git command pushes the remote setup but doesn’t actually include all your local files. If you look at the GitHub repo and see only the README, here’s what to do:

In WebStorm, press `Command+K` (Mac) or `Ctrl+K` (Windows) to open the **Commit** dialog. Scroll down and you’ll see a section that says something like “Unversioned files.” Check that box, this tells git to include everything that isn’t tracked yet. In the commit message field, type something like `Adding all files`. Then click the dropdown arrow next to Commit and choose **Commit and Push**.

WebStorm will warn you about things, just acknowledge them and push anyway. Go back to GitHub, refresh, and now all your files should be there.

💡

The WebStorm commit dialog is actually one of the nicer ways to do this, it gives you a visual of exactly what’s getting committed and what’s being left out. Once you get the hang of it, you’ll probably prefer it over typing git commands manually.

---

## 4\. Step 2: Deploy with Vercel *(\~5:40)*

### 4.1 Sign Up for Vercel

Open a new browser tab and go to [vercel.com](https://vercel.com/?ref=deletosh.com). Click **Start Deploying**.

Vercel will ask you to sign in. Choose **Continue with GitHub**: this is the fastest path and it means Vercel can access your repos directly without any extra configuration. Click Authorize when GitHub asks for permission.

Vercel will pull in your account almost immediately.

### 4.2 Import Your Project

Once you’re in the Vercel dashboard, it should show you your GitHub repositories. Find the one you just created. If you only have one repo, it’ll probably already be highlighted.

Click **Import**.

Vercel will try to detect what kind of project it is. For a simple HTML/CSS page, there’s nothing to configure. Leave all the defaults as-is. Don’t change the project name, don’t touch the build settings.

Click **Deploy**.

### 4.3 Watch It Deploy

Vercel will say “deployment starting” and then it’ll finish, usually in under a minute. When it’s done, click **Continue to Dashboard**.

You’ll see a preview of your page right there in the dashboard. Click **Visit** to open it in the browser.

That’s it. Your page is live.

---

## 5\. You’re Live: Here’s What That Means *(\~7:00)*

When you open that URL in the browser, notice it: it should be something like `your-project-name.vercel.app`. That URL is public. Anyone anywhere in the world can type it in and see your page. It’s not on localhost anymore.

This is real.

That said, `yourproject.vercel.app` doesn’t look like a proper website domain. Most things you visit on the internet have something clean like `google.com` or `yourproduct.co`. The reason we’re getting the Vercel subdomain for now is because Vercel gives it to us for free. It’s a hosted URL, just with their domain on it.

In the next lesson, we’re going to fix that. We’ll buy a proper domain name and attach it to this Vercel deployment so your page has a real, professional address. But the site being live right now, that part is done.

✅

If you’ve got a working URL on [vercel.app](https://vercel.app/?ref=deletosh.com) and the page loads, you’re done with this lesson. The foundation is in place. Next up: a proper domain.

---

## 6\. Try It Yourself

### Exercise 1: Get It Live

**What to do:** Follow sections 3 and 4\. Create the GitHub repo, push your files, connect Vercel, and get to the point where you have a live `vercel.app` URL.

**A nudge if you’re stuck:** If your files aren’t showing up on GitHub after the first push, go to the Commit dialog in WebStorm (`Command+K` / `Ctrl+K`), check the “Unversioned files” box, and do a Commit and Push. That’ll catch anything git missed.

**How you’ll know it’s working:** You’ll have a URL ending in `.vercel.app` that loads your landing page in the browser, not just a local preview, but a real link you can share with anyone.

### Exercise 2: Share the Link

**What to do:** Once your page is live, copy the Vercel URL and send it to someone, a friend, a family member, anyone. Ask them to confirm they can see it.

**What this is practising:** End-to-end verification. “It works on my machine” is not the same as “it works.” Confirming someone else can load it closes that loop.

---

## 7\. You Should Be Able to Build This Now

Here’s what you can do with what we just covered:

- Push any local project to a GitHub repo using WebStorm’s terminal
- Connect a GitHub repo to Vercel and deploy a live website in under five minutes
- Understand the GitHub → Vercel pipeline and how automatic deploys work

### Check Yourself

- I have a GitHub account and my project is in a private repository
- All my project files (including `index.html`) are visible in the GitHub repo
- My site is deployed on Vercel and I have a live `.vercel.app` URL
- I’ve opened that URL in the browser and confirmed the page loads correctly

✅

Tick those boxes and you’re ready for Module 4, Lesson 4, where we attach a proper custom domain to this deployment.

### If Something’s Not Working

⚠️

****Authentication failed when pushing to GitHub**  
****What’s happening:** GitHub no longer accepts plain passwords over HTTPS. You need either SSH authentication or a personal access token.  
****How to fix it:** Switch to the SSH version of the push command (toggle the SSH tab on the GitHub repo page), or set up a GitHub personal access token and use that as your password. If neither option works for you, drop a question in Discord.

⚠️

****Only README showing on GitHub, not index.html**  
****What’s happening:** Git initialised but didn’t stage your existing files for commit, only the README was tracked.  
****How to fix it:** In WebStorm, open the Commit dialog (`Command+K` / `Ctrl+K`), scroll to “Unversioned files,” check that box, write a commit message, and choose Commit and Push.

⚠️

****Vercel deployment failed**  
****What’s happening:** Usually a configuration issue, Vercel is trying to run a build command that doesn’t apply to a plain HTML file.  
****How to fix it:** Go to your project settings in Vercel → Build & Output Settings → clear out any build command that was auto-detected. For a plain HTML project, there’s nothing to build. Leave everything blank and redeploy.

⚠️

****Can’t find my repo in Vercel during import**  
****What’s happening:** Vercel may not have permission to see all your GitHub repos, only the ones you’ve granted access to.  
****How to fix it:** In Vercel during import, look for an option like “Adjust GitHub App Permissions” or “Configure GitHub App.” Click that and grant Vercel access to the specific repo you created.

---

## The Short Version

Here’s what I want you to walk away with:

- **GitHub stores your code**: it’s the source of truth that Vercel reads from
- **Vercel hosts your site**: connect it to GitHub, click deploy, done
- **The pipeline is now live**: every time you push changes to GitHub, Vercel can redeploy automatically
- **The `.vercel.app` URL is real and public**: anyone can visit it, but the domain name needs work, that’s Module 4, Lesson 4

---

## Quick Reference

### Terminal Command to Open in WebStorm

```
Alt+F12   ← open terminal (Windows/Linux)
Command+E → type "terminal"   ← open terminal (Mac)

```

### WebStorm Commit Shortcut

```
Command+K (Mac) / Ctrl+K (Windows)   ← open Commit dialog

```

### Fix: Clear Broken Git State

```
rm -rf .git

```

Run this in your project folder if you hit authentication errors and want to start the git setup fresh. Then paste the GitHub command block again.

### Deployment Pipeline

```
Your machine → WebStorm terminal (git push) → GitHub repo → Vercel → Live URL

```

---

## Resources

### Links & Docs

- [GitHub](https://github.com/?ref=deletosh.com)sign up here if you don’t have an account
- [Vercel](https://vercel.com/?ref=deletosh.com)free hosting with GitHub integration
- [GitHub SSH Setup Guide](https://docs.github.com/en/authentication/connecting-to-github-with-ssh?ref=deletosh.com)if you want to use SSH authentication instead of HTTPS

---

### Tools Used

- [GitHub](https://github.com/?ref=deletosh.com)version control and code hosting
- [Vercel](https://vercel.com/?ref=deletosh.com)deployment and hosting platform
- WebStorm, IDE used throughout the course (VS Code works fine too)

---

## Questions I Get Asked

**Q: Why GitHub? Can I use GitLab or Bitbucket?**

Vercel supports all three, GitHub, GitLab, and Bitbucket. I use GitHub because it’s what I know and it’s where the starter repo lives. If you’re already set up with one of the others, Vercel will still connect fine.

**Q: Do I have to make the repo public for Vercel to work?**

No. Vercel works with private repos, it connects via GitHub’s app permissions, not public access. Keep it private if you want; deployment will still work.

**Q: The Vercel URL looks weird. Do I need to fix it?**

Not yet. The `something.vercel.app` URL is a free subdomain that Vercel gives every project. It’s real and it works, it’s just not your final domain. We fix that in the next lesson by adding a custom domain name.

**Q: What happens when I update my landing page? Do I have to do this all again?**

No, once the GitHub → Vercel connection is set up, every push to GitHub triggers an automatic redeploy. So your workflow going forward is: make changes in WebStorm → commit and push → Vercel picks it up and redeploys automatically. You don’t need to go back into Vercel unless something breaks.

**Q: How do I know I’m ready for the next lesson?**

You need a working `vercel.app` URL that loads your page. That’s the only requirement for Module 4, Lesson 4\. Don’t move on until that link works.

---

## 💬 Stuck? Come Talk to Us

💡

If something’s not clicking or you want to share what you’ve built, come find us in Discord.  
****The Product Path community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community’s active and I check in there too.

---

## Glossary

**GitHub:** A cloud-based platform for hosting git repositories. Where your project code lives so Vercel (and you) can access it from anywhere. *(referenced throughout Module 1 as a prerequisite; first used actively in this lesson, Module 4, Lesson 3)*

**Repository (repo):** A project’s home on GitHub. Contains all the files, commit history, and version tracking for your project. *(first actively used in Module 4, Lesson 3)*

**Vercel:** A hosting and deployment platform that connects to your GitHub repo and makes your website publicly available on the internet. Free tier is sufficient for a landing page at this stage. *(introduced in Module 4, Lesson 3)*

**Deployment:** The process of taking your code and making it live on the internet. In our setup: push to GitHub → Vercel picks it up → your site updates. *(introduced in Module 4, Lesson 3)*

**localhost:** The address your computer uses to serve a website only to itself, nobody else can access it. `http://localhost:3000` (or similar) means “running on my machine only.” Getting off localhost is what this lesson is about. *(implicitly referenced throughout Module 4; explicitly addressed in Module 4, Lesson 3)*

**SSH (Secure Shell):** An authentication method for connecting to services like GitHub. More secure and convenient than username/password once it’s set up, you don’t need to re-enter credentials every time you push. *(mentioned as an alternative authentication method in Module 4, Lesson 3)*

**git push:** The terminal command that sends your locally committed changes up to your GitHub repo. Once it’s there, Vercel can deploy it. *(first used in Module 4, Lesson 3)*

**Commit:** A snapshot of your project at a specific point in time, saved in git. Before you can push to GitHub, you commit your changes locally. *(first used actively in Module 4, Lesson 3)*
### Module 4, Lesson 2: Connect to ConvertKit
URL: https://deletosh.com/courses/product-path/04-02-connect-convertkit/
Last updated: 2026-07-16T15:33:50.000Z
## How do you connect a landing page to Kit (ConvertKit)?

You connect a landing page to Kit (formerly ConvertKit) by creating a Kit form, copying its Form ID and API key, and having Claude Code wire your page's email input to Kit so every submission lands in your subscriber list.

You do not touch the integration code yourself; you hand Claude the two values and it does the wiring, then you test the full flow end to end. Kit is free for your first 10,000 subscribers, so your waitlist can start capturing real emails from the first visitor at no cost.

**The short version: you wire your landing page form to ConvertKit so every email signup is captured and ready for nurture from the first visitor. Getting the list live early is what lets demand start compounding. The full integration is inside The Product Path.**

## Before We Start

Here’s what I’d expect you to have in place before this lesson:

**From previous lessons:**

- Your landing page from[ Module 4, Lesson 1](https://deletosh.com/courses/product-path/04-01-design-landing-page/)with a working email CTA input, is ready to go
- Claude Code is installed and you’re comfortable running it inside the WebStorm terminal (Module 3, Lesson 3)
- WebStorm is set up and your project is open (Module 3, Lesson 1)

**Tools / setup you’ll need:**

- WebStorm (or VS Code)
- Claude Code running in the WebStorm terminal
- A Kit (ConvertKit) account, free tier, sign up at [kit.com](https://kit.com/?ref=deletosh.com) if you haven’t yet

**By the end of this lesson, you’ll:**

- Have Kit (ConvertKit) set up and connected to your landing page
- Understand what a Form ID and API key are and where to find them
- Be able to capture real email addresses from your landing page into your Kit subscriber list
- Know how to test the integration end-to-end

---

## What Is This Lesson About?

**Duration:** \~12 minutes video + \~15 minutes practice  
**Skill Level:** Intermediate  
**What You’ll Build:** A live email capture integration between your landing page and Kit (ConvertKit)

The landing page we built in the last lesson looks the part, but it’s not doing its job yet. A waitlist page that doesn’t capture emails is just a pretty picture. In this lesson we make it real: every email someone types in gets routed into Kit, stored in your list, and available for you to follow up on.

---

## Watch the Lesson

---

ℹ️

****How I’d suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section, pausing the video at the timestamps I’ve noted. After that, this guide is your reference, you shouldn’t need to rewatch to look something up.

---

## What We’re Covering

Here’s what I’m walking you through in this lesson and why it matters if you’re trying to ship real things:

- **Why you need a marketing automation system**: and why Kit is the right tool to start with (it’s free for your first 10,000 subscribers)
- **Creating a Kit Form**: the standing form that acts as the entry point for your subscriber list
- **Finding your Form ID and API key**: the two pieces of information Claude needs to wire everything up
- **Letting Claude do the integration**: you don’t need to touch the code directly
- **Testing the full flow**: making sure emails actually land in your Kit list
- **The “auto-confirm” setting**: a small but important tweak that makes the confirmation flow actually work

---

## 1\. Let’s Set the Scene *(\~0:00)*

In the last lesson, we completed the landing page. It looks great, the CTA is there, and if someone types in their email and clicks the button it says “added to waitlist.” But here’s the thing, that email doesn’t actually go anywhere.

So what we’ve built so far is a form that *looks* like it works. What we’re going to do now is connect it to something real: a marketing automation system. And the tool I’m using for this is **Kit**: which you might know as ConvertKit. They rebranded, but same product.

The reason I like Kit for this stage is simple: it’s completely free for your first 10,000 subscribers. You’re not paying for anything until you’ve got real traction, and by then, you’ll be glad the system is already in place.

---

## 2\. The Core Idea

### 2.1 What a Marketing Automation System Actually Does

Here’s the simple version of what we’re setting up: when someone visits your landing page and types in their email address, that email needs to go *somewhere*somewhere you can find it, manage it, and send messages to it. That somewhere is Kit.

Kit stores the email, adds the person to your subscriber list, and from there you can send them messages, updates, sequences, whatever you want. Right now we’re just doing step one: get the email into the list.

Think of Kit as the inbox for your waitlist. The landing page is just the front door.

### 2.2 Why We’re Not Building This Ourselves

You could theoretically build your own email capture backend, a database, an API endpoint, a send function. But you don’t need to. Kit handles all of that, it’s already got the infrastructure, the deliverability, the double opt-in flows, the unsubscribes. There’s no reason to reinvent that wheel at this stage. Use the free tool, connect it, move on.

### 2.3 How This Connects to Module 4, Lesson 1: Design the Landing Page

In Module 4, Lesson 1, we built the CTA input on the landing page. Right now that input fires a “success” state locally, but the email goes nowhere. In this lesson we’re completing that loop by giving the form a real destination.

---

## 3\. Setting Up Kit *(\~0:30)*

### 3.1 Sign Up for Kit

If you haven’t already, go to [kit.com](https://kit.com/?ref=deletosh.com) and sign up. You want the free plan, it says **$0/month for the first 10,000 subscribers**, which is right there on the pricing page. You don’t need to put in a card.

Once you’re logged in, don’t let the dashboard overwhelm you. There’s a lot on screen. We’re only touching one small part of it.

### 3.2 Create a Form

Here’s the thing about Kit forms: we’re not using Kit’s visual form on our landing page, we’ve already built our own form in the HTML. What we need from Kit is just a **standing form** that acts as the entry point to our subscriber list. Think of it as a hook we attach our custom form to.

Here’s how to create it:

1. In Kit, go to **Grow → Landing Pages & Forms**
2. Click **Create New**
3. Select **Form** (not Landing Page)
4. Choose **Inline Form** as the type
5. Pick any template, it doesn’t matter which one, we’re not using the visual design
6. Give it a name, I called mine **“waitlist”** but name it whatever makes sense for your project
7. Click **Save and Publish**

ℹ️

The template you choose doesn’t matter at all, you’re not using Kit’s form visually. You’re just creating the form so it exists as a destination for your custom HTML form to send data to.

### 3.3 Get Your Form ID

Once your form is saved, look at the URL in your browser while you’re viewing that form. You’ll see a number in the URL, that’s your **Form ID**.

Copy it and paste it somewhere safe, a scratch pad, a text file, anywhere you’ll find it in the next few minutes. You’ll need it shortly.

⚠️

The Form ID is in the URL of the form page itself, not the embed code, not the settings. Just look at the URL bar when you’re viewing the form in Kit and you’ll see it.

### 3.4 Get Your API Key

1. In Kit, click on your **profile picture** (top right)
2. Go to **Settings**
3. Scroll down to **Developer**
4. Your API key is right there, click **Copy**

Paste that next to your Form ID in your scratch pad. You now have the two things Claude needs.

💡

Kit’s API key (v3) is a public key, it’s fine to use in a client-side integration like this. You’re not exposing anything sensitive. This is expected behaviour for a public-facing form.

---

## 4\. Let Claude Do the Integration *(\~3:30)*

### 4.1 The First Prompt

Here’s what I ran in Claude Code to build the integration. Open your terminal in WebStorm, launch Claude Code, and paste this:

```
update my CTA input to integrate with ConvertKit so that when a user enters their email address, it goes into kit and i'm able to follow up with them.

After building the integration, walk me through setting up kit to work with my landing page

```

ℹ️

Claude Code will write the integration into your `index.html` and then give you step-by-step instructions for how to configure Kit. The instructions might not perfectly match what you see in Kit’s interface, they change their UI fairly often. Use Claude’s output as a guide for what it’s trying to get you to do, not as a pixel-perfect walkthrough.

Claude will ask for permission before writing files (as usual), write the code, and then give you the Kit setup instructions. Follow along with those instructions to set up the form in Kit, the steps in section 3 above are exactly what Claude was guiding me through.

### 4.2 The Second Prompt: Plug In Your Keys

Once you’ve got your Form ID and API key from Kit, you don’t need to manually edit the code. Just send Claude a second prompt:

```
update my index.html with these
form id: [YOUR FORM ID]
API key: [YOUR API KEY]

```

Replace `[YOUR FORM ID]` and `[YOUR API KEY]` with the actual values from your Kit scratch pad. Claude will update the file for you, no digging around in the HTML required.

💡

This is a good example of the pattern we use throughout the course: Claude builds the structure, you supply the real values, Claude wires them in. You stay in control without needing to be fluent in the code.

---

## 5\. Fix the Confirmation Flow *(\~9:00)*

### 5.1 Why Nothing Showed Up the First Time

When I first tested the integration, typed a test email, clicked the button, saw “added to waitlist”, I went to Kit and saw zero subscribers. Nothing.

The reason: Kit defaults to a double opt-in flow. It sends the person an email asking them to confirm before it adds them to your list. If you use a fake email address (which I did the first time), there’s nobody to click confirm, so nothing shows up.

The fix for testing purposes is to either use a real email address, or adjust the confirmation settings.

### 5.2 The Auto-Confirm Setting

Here’s the tweak I made in Kit to smooth out the confirmation flow during testing:

1. Go to your form in Kit (**Grow → Landing Pages & Forms** → click your form)
2. Click on **Settings** for the form
3. Find **Incentive** settings
4. Under **Send Incentive Email**, you’ll see an option for **Auto-confirm new subscribers**
5. Uncheck **Send incentive email** (for now) and enable **Auto-confirm new subscribers**
6. Save the form

⚠️

****This is a testing setting, not a production recommendation.**  
Double opt-in is good practice, it means people actively confirm they want to hear from you, which keeps your list clean and your deliverability healthy. For testing, it’s fine to auto-confirm. But once you’re live, consider whether you want to turn that back on.

### 5.3 Test With a Real Email

After adjusting that setting, go back to your landing page (open it in Chrome, refresh the page), type in a **real email address**, and click the button.

Then go back to Kit, **Grow → Landing Pages & Forms** → click your form → check the **Reports** tab. You should see a subscriber count go up.

You’ll also get a confirmation email to that address, Kit’s default behaviour. When I tested it, mine landed in spam initially. That’s normal for a brand new domain/sender setup, we’ll sort out email deliverability in a later lesson.

---

## 6\. Try It Yourself

### Exercise 1: Connect Your Form to Kit

**What to do:** Follow the steps in sections 3 and 4\. Create a Kit form, get your Form ID and API key, run both Claude prompts, and verify the code has been updated in your `index.html`.

**A nudge if you’re stuck:** If Claude’s instructions for Kit setup don’t match exactly what you see in the Kit UI, just focus on the *goal* of each step, create a form, find its ID, find the API key. The UI changes but the concepts don’t.

**How you’ll know it’s working:** Your `index.html` file should now have your Form ID and API key referenced in it. Claude will confirm it updated the file after the second prompt.

### Exercise 2: Test the Full Flow End to End

**What to do:** Open your landing page in Chrome, type a real email address into the CTA input, and click the button. Then go to Kit and verify the subscriber appeared.

**What this is practising:** End-to-end thinking, don’t just assume the integration works because Claude wrote it. Always test the thing yourself.

---

## 7\. You Should Be Able to Build This Now

Here’s what you can do with what we just covered:

- Connect any HTML email capture form to a Kit subscriber list
- Use Claude Code to handle the integration code and then feed it real credentials via a follow-up prompt
- Test and verify email capture end-to-end

### Check Yourself

- I’ve created a Kit form and know where to find my Form ID
- I’ve located my API key in Kit’s Developer settings
- I’ve run both Claude prompts and my `index.html` has been updated
- I’ve tested with a real email and verified the subscriber appeared in Kit
- I understand what double opt-in is and why the auto-confirm setting matters for testing

✅

If you’re ticking those boxes, your waitlist is actually working, emails are going somewhere real. That’s the milestone for this lesson. Nice work.

### If Something’s Not Working

⚠️

****Subscriber not showing up in Kit**  
****What’s happening:** Kit’s double opt-in means the subscriber won’t appear until the confirmation email is clicked. Using a fake or inaccessible email means nothing gets confirmed.  
****How to fix it:** Use a real email address you can access, or go into your Kit form settings → Incentive → uncheck “Send incentive email” and enable “Auto-confirm new subscribers” while testing.

⚠️

****Confirmation email went to spam**  
****What’s happening:** This is expected for new senders, email deliverability takes a bit of work to set up properly.  
****How to fix it:** We’ll cover this in a later lesson. For now, just verify the email arrived (even in spam) and confirm the subscriber shows up in Kit after you click the confirmation link.

⚠️

****Claude’s Kit setup instructions don’t match what I see**  
****What’s happening:** Kit updates their UI regularly. Claude’s instructions are based on the version it knows, the UI might look different for you.  
****How to fix it:** Focus on the goal of each step, not the exact navigation path. If you’re looking for the API key and it’s not where Claude said, check under Settings → Developer.

---

## The Short Version

Here’s what I want you to walk away with:

- **Kit is your marketing automation system**: free for your first 10,000 subscribers, and it handles all the email infrastructure so you don’t have to
- **You need two things to connect your form to Kit**: the Form ID (in the URL of your form) and your API key (Settings → Developer)
- **Claude does the code**: give it the first prompt to build the integration, then a second prompt with your real credentials to wire them in
- **Always test with a real email**: fake emails can’t confirm subscriptions, so you won’t see anything in Kit until a real person (or you) confirms

---

## Quick Reference

### The Two Prompts

**Prompt 1, Build the integration:** \`\`\` update my CTA input to integrate with ConvertKit so that when a user enters their email address, it goes into kit and i’m able to follow up with them.

After building the integration, walk me through setting up kit to work with my landing page \`\`\`

**Prompt 2, Plug in your credentials:** `update my index.html with these form id: [YOUR FORM ID] API key: [YOUR API KEY]`

### Where to Find Things in Kit

| What you need        | Where to find it                                                |
| -------------------- | --------------------------------------------------------------- |
| Form ID              | URL bar when viewing your form in Kit                           |
| API Key              | Profile → Settings → Developer                                  |
| Auto-confirm setting | Grow → Landing Pages & Forms → your form → Settings → Incentive |
| Subscriber count     | Grow → Landing Pages & Forms → your form → Reports              |

---

## Resources

### Links & Docs

- [Kit (ConvertKit)](https://kit.com/?ref=deletosh.com)sign up for the free plan here
- [Kit API Documentation](https://developers.kit.com/?ref=deletosh.com)if you ever want to go deeper on what the integration is doing under the hood

### Tools Used

- [Kit (ConvertKit)](https://kit.com/?ref=deletosh.com)email marketing and marketing automation platform
- Claude Code, running in the WebStorm terminal, same as Module 3, Lesson 3 onwards

---

## Questions I Get Asked

**Q: Do I have to use ConvertKit / Kit? Can I use Mailchimp or something else?**

Totally. The principle is the same regardless of which tool you use, you need a Form ID (or equivalent) and an API key, and you give Claude those details to wire up the integration. Kit is what I use and it’s free to start, so it’s what I’m showing here. But if you’re already using Mailchimp, Beehiiv, or something else, the same pattern applies, just ask Claude to integrate with that instead.

**Q: Is it safe to put my API key in the HTML file?**

Kit’s v3 API key is a public key, it’s designed to be used client-side for exactly this kind of form integration. It’s not a secret token that grants admin access to your account. That said, once we push this to production in the next lesson, you might want to revisit how you’re managing environment variables. For now, for a landing page in this stage, it’s fine.

**Q: The confirmation email went to spam, is something broken?**

Nothing is broken. Email deliverability is a real thing that takes a bit of setup, domain verification, DKIM records, SPF records. We’ll cover this properly in a later lesson. For now, if the email arrived at all (even in spam) and clicking the confirmation link added you to the Kit list, the integration is working correctly.

**Q: How do I know I’m ready for the next lesson?**

If emails are landing in your Kit list and you’ve confirmed it end-to-end with a real email address, you’re good. The next lesson is about getting this page live on the internet, so make sure the integration is working locally before we move on.

---

## 💬 Stuck? Come Talk to Us

💡

If something’s not clicking or you want to share what you’ve built, come find us in Discord.  
****The Product Path community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community’s active and I check in there too.

---

## Glossary

**Kit (ConvertKit):** An email marketing and marketing automation platform. Free for your first 10,000 subscribers. Used here to capture and store email addresses from your waitlist landing page. *(first introduced in this lesson, Module 4, Lesson 2)*

**Marketing automation system:** A platform that stores subscriber email addresses and lets you send automated or manual messages to them. Kit is the one we’re using throughout this course. *(introduced in Module 4, Lesson 2)*

**Form ID:** A unique identifier for a specific form in Kit. Found in the URL of your form when viewing it in Kit. Needed to tell your landing page which Kit form to submit data to. *(introduced in Module 4, Lesson 2)*

**API key:** A string of characters that authenticates your landing page’s requests to Kit’s API. Found in Kit under Settings → Developer. Kit’s v3 API key is a public key, safe to use in client-side code. *(introduced in Module 4, Lesson 2)*

**Double opt-in:** An email subscription practice where someone receives a confirmation email after signing up and must click a link to confirm before they’re added to your list. Good for list quality and deliverability. *(introduced in Module 4, Lesson 2)*

**Auto-confirm:** A Kit form setting that skips the double opt-in confirmation email and adds the subscriber immediately. Useful during testing; consider carefully before using in production. *(introduced in Module 4, Lesson 2)*

**CTA (Call to Action):** The primary prompt or input element on your landing page that invites the visitor to take action, in our case, entering their email address. *(first used in Module 4, Lesson 1, Design the Landing Page)*
### Module 4, Lesson 1: Design the Landing Page
URL: https://deletosh.com/courses/product-path/04-01-design-landing-page/
Last updated: 2026-07-16T15:33:48.000Z
## How do you design a landing page with Claude Code?

You design a landing page with Claude Code by cloning a starter repo into WebStorm, copying your Module 2 documents (GTM, market research, summary, UX/UI) into a folder so Claude has context, then running the frontend-design skill to have Claude research your competitors and generate the copy and layout.

You refine the result by sending screenshots and follow-up prompts until it looks right. In this lesson the goal is a working, styled waitlist page framed as early access rather than a wait, ready to preview and drive traffic to.

**The short version: you feed Claude the positioning and documents you have built and prompt it to translate them into landing page copy and layout aimed at conversion, not just description. Your research becomes a page that sells. The full design workflow is inside The Product Path.**

In this lesson, we’re picking up everything we’ve built across Modules 2 and 3, all that research, documentation, and planning, and using it to ship our first real thing: a landing page.

ℹ️

No corrections to previous lessons to flag here. We’re picking up right where Module 3 left off.

---

## Before We Start

Here’s what I’d expect you to have under your belt before this lesson:

**From previous lessons:**

- You should have your GTM, Market Research, Summary, and UX/UI documents already generated from Module 2
- WebStorm should be installed and working, we set that up in Module 3, Lesson 1
- Claude Code should be installed and you should be comfortable running it inside the WebStorm terminal, Module 3, Lesson 3

**Tools / setup you’ll need:**

- WebStorm (or VS Code as an alternative)
- Claude Code, running in the terminal
- Your documents from[ Module 2: GTM, Market Research, Summary, UX/UI doc](https://deletosh.com/courses/product-path/02-00-module-intro/)
- GitHub account and git configured locally
- CleanShot (Mac) or ShareX (Windows), useful for taking annotated screenshots to send to Claude

**By the end of this lesson, you’ll:**

- Have a starter repo cloned and set up locally in WebStorm
- Understand how to use the frontend-design skill with Claude Code to generate a professional landing page
- Know how to iterate on Claude’s output using screenshots and follow-up prompts
- Have a working landing page that you can preview in the browser, ready to go live

---

## What Is This Lesson About?

**Duration:** \~27 minutes video + \~30 minutes practice   
**Skill Level:** Intermediate   
**What You’ll Build:** A working, styled landing page for your product, including a waitlist CTA, pricing table, and competitor-informed messaging

This is the lesson where everything we’ve been building toward starts to feel real. We’ve done the research, written the docs, planned the sprints, now we’re putting something live on the internet. I’ll show you how I use Claude Code with the frontend-design skill to go from zero to a polished landing page, and how to iterate on it using screenshots when the output needs tweaking.

---

## Watch the Lesson

---

ℹ️

****How I’d suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section, pausing the video at the timestamps I’ve noted. After that, this guide is your reference, you shouldn’t need to rewatch to look something up.

---

## What We’re Covering

Here’s what I’m walking you through in this lesson:

- **Cloning the starter repo**: getting the boilerplate set up in WebStorm so you have a structured starting point
- **Populating the `.sales` folder**: copying your Module 2 documents into the project so Claude has the right context
- **Running the first prompt**: using the frontend-design skill to have Claude research your competitors and design the page
- **Answering Claude’s clarifying questions**: how to give Claude the answers it needs to make the right design decisions
- **Iterating with screenshots**: a practical workflow for refining the output when something doesn’t look right
- **The waitlist framing trick**: why I never make a waitlist look like a waitlist

---

## 1\. Let’s Set the Scene *(\~0:00)*

This is the module I’ve been looking forward to since we started. We’ve done a lot of upfront work, research, documentation, specs, planning, and now we’re going to actually build something you can show people.

The first thing we’re building is the landing page. Not the full app, just the page people land on to learn about your product and sign up. And the reason we start here is straightforward: I want you to be able to start driving traffic and collecting interest *before* the product is finished. That’s how you validate demand. That’s how you build a list of real people who care.

The goal of this page is to get people onto a waitlist. But here’s the thing, I don’t want it to feel like a waitlist. Nobody wants to wait. So we’re going to frame it as early access, as something premium and exclusive. The mechanics are the same; the positioning is everything.

ℹ️

Even if you’re not particularly technical, stick with this. We’re going to be using Claude heavily, and I’ll walk through every step. The goal is for you to understand the process well enough to do it yourself, not to memorise every keystroke.

---

## 2\. The Core Ideas

### 2.1 Why We Start with a Landing Page

We’re not building the full app first. We’re building the page that proves people want it.

The reason for this order is simple: if nobody shows up to the landing page, or nobody signs up, that’s useful data. It means something about your positioning, your market, or your timing needs to change, and you’ve learned that before sinking months into an app. If people *do* sign up, you’ve got a list of real interested users to talk to while you build.

This is a bias toward shipping small things early and learning from them.

### 2.2 The Frontend-Design Skill

Claude Code supports what I call skills, essentially specialized instructions that give Claude a particular area of expertise. For this lesson, the starter repo includes a frontend-design skill that I’ve written specifically for this course. When Claude reads it, it knows how to approach landing page design the way a senior front-end designer would: distinctive typography, intentional layout, conversion-focused copy, and the kind of micro-interactions that make a page feel premium rather than generic.

You don’t need to understand everything in that skill file. What matters is that when you reference it in your prompt, Claude brings a much higher level of design thinking than it would otherwise.

### 2.3 Why the `.sales` Folder Matters

All the documents we generated in Module 2, the GTM, the market research, the UX/UI doc, the summary, those aren’t just filing exercises. They’re the context Claude needs to design a page that’s actually tailored to your product and your market.

By putting those documents in the `.sales` folder and pointing Claude to them, you’re not asking it to guess who your users are or what your competitors look like. It reads your actual research and designs from that foundation. That’s why the output is grounded in real data, not AI guesswork.

---

## 3\. Let Me Show You How It Works

### 3.1 Step 1: Clone the Starter Repo

The starter repo gives you a structured project with the right folder layout, MCP configuration, and the frontend-design skill already in place. You don’t have to set any of that up from scratch.

Go to:

```
https://github.com/deletosh/tpp-landing-page-starter

```

In WebStorm, go to **File → New → Project from Version Control** (or look for “Clone Repository” on the welcome screen). Paste the repo URL, then change the destination folder name to match your product, I named mine `nurturo-landing-page`.

⚠️

****Git not showing up?** If you don’t see a GitHub option when cloning, git probably isn’t configured on your machine yet. I’ve included setup notes below in the Resources section. Get that sorted first, then come back here. If you’re stuck, drop a question in the Discord.

### 3.2 Step 2: Populate the `.sales` Folder

Once the project is open in WebStorm, you’ll see a `.sales` folder in the left panel. This is where you put your documents from Module 2.

Here’s how to do it:

1. Open Obsidian (or wherever you saved your documents)
2. Right-click your vault folder and choose **Reveal in Finder** (Mac) or **Show in Explorer** (Windows)
3. Select your GTM, Market Research, Summary, and UX/UI documents
4. Copy them
5. In WebStorm, right-click the `.sales` folder and paste

When it asks about adding files to git, say yes. Don’t worry about what that means right now; we’ll get to git tracking shortly.

💡

You don’t need every document, at minimum, have your GTM, Market Research, Summary, and UX/UI doc. Those are the ones Claude will draw on most heavily for the landing page.

### 3.3 Step 3: Launch Claude Code

Open the terminal in WebStorm. I use Command + E and then type “terminal”, yours might open at the bottom of the screen by default. Position it however works for you; I like mine on the right side so I can see the project files on the left.

Now type:

```
claude --model claude-opus-4-6 --mcp-config .mcp.json

```

The `--model` flag lets me specify which Claude model to use. As of when I recorded this, Opus 4.6 is the latest. The `--mcp-config` flag points Claude to the MCP configuration file in the project root, that’s what gives it access to the tools we’ve set up (like Vercel, which we’ll use in a later lesson).

When it asks if you trust this folder, say yes.

### 3.4 Step 4: Run the First Prompt

Once Claude Code is running, paste in this prompt:

```
Review my app info in the .sales directory. Based on this, use the frontend-design skill to research my competition and design a standout landing page.

Before you design, ask me all the clarifying questions you need.

```

This is intentionally a two-stage prompt. I’m not asking Claude to just go and build something. I’m asking it to read my research first, then come back with questions before it touches any code. That step matters, the questions it asks will shape the design.

---

## 4\. Answering Claude’s Questions

### 4.1 What to Expect

After Claude reads your `.sales` documents, it’ll come back with a list of clarifying questions. These aren’t bureaucratic, they’re genuinely shaping decisions about layout, messaging, and visual direction. Take a few minutes and answer them properly.

Here’s roughly what it asked me, and how I answered:

**Do you have a logo?** I said: just use a wordmark. No icon. Keep it simple.

**Should I follow the colour palette from the UX/UI document?** Yes, follow it exactly. That’s why we planned it.

**Is this a pre-launch page?** Yes.

**Who is the primary visitor, the user or a related persona?** In my case, the separated parent. The app has two user types, but the landing page is aimed at one of them specifically.

**Do you have real testimonials?** No. I told Claude to research real frustrations from public forums (Reddit, app reviews) and use those as social proof, framed honestly as documented community frustrations, not fake reviews.

**Do you have app screenshots?** No. The app isn’t built yet. I told it to use descriptive illustrations and icons instead.

**Do you want a full pricing table?** Yes, include it.

**What should the primary CTA be?** Waitlist, but don’t make it look like one. Frame it as early access. I was pretty direct: *it’s a waitlist, but don’t make it look like one.*

**How aggressively do you want to reference competitors?** Imply it, don’t name them. I don’t want to do free marketing for competitors, and I don’t want to create any legal exposure.

**Just the main landing page?** Yes. One page.

💡

You don’t need to write essays here. Short, clear answers are fine. Claude is reading these to make design decisions, not writing your copy.

---

## 5\. Iterating on the Output

### 5.1 First Pass

After you answer the questions, Claude will go research your competitors’ pages, actually visiting their sites and pulling real data, then build your landing page as `index.html`. Once it’s done, open the file in WebStorm and click the little browser icon (the WS icon) in the top right of the file editor. This previews the page locally in your browser.

Take a scroll through. Look at it on both desktop and mobile, mobile matters more for most products.

The first pass might be functional but a little generic-looking. That’s expected. What I got looked decent, but the font was common and the design felt a bit bland. So I ran a follow-up:

```
Update the design to make the page pop a bit more and not look generic. Use non-common font pairings and introduce elements that will be relevant to our prospects.

```

The second pass was noticeably better, distinct typography (DM Serif Display, if you’re curious), micro-interactions on hover, a sticky CTA that follows you as you scroll, and a visual language that felt more premium.

### 5.2 Fixing Specific Issues with Screenshots

Here’s a trick I use constantly: if something looks off visually, I take a screenshot of that specific area, paste it directly into Claude Code, and tell it what’s wrong.

On Mac, I use CleanShot. On Windows, ShareX. Take the screenshot, copy it, then in the Claude Code terminal do **Ctrl+V** (not Command+V on Mac, it’s Ctrl) to paste the image directly into the prompt.

Then just say what’s wrong:

```
[paste screenshot] This is not aligned. Please fix.

```

Or:

```
[paste screenshot] This logo looks tacky. Make it more premium — wordmark only, no icon.

```

Claude can’t actually see your browser, so it’s reading the code and making educated guesses. The screenshot closes that gap. If it doesn’t get it right on the first try, paste another screenshot and say: *you can do better.*

### 5.3 Checking Your Page

Before you move on, do a quick review:

- Scroll through on mobile, does everything look right?
- Click the CTA button, does it scroll or link correctly?
- Check the pricing toggle (annual/monthly), does it switch?
- Any navigation links, do they go somewhere sensible?

The email input won’t actually *do* anything yet. We’ll wire that up in the next lesson when we connect to ConvertKit.

---

## 6\. The Waitlist Framing Trick

I mentioned this briefly in the video, so I want to be explicit about it here.

Nobody wants to be on a waitlist. It signals “this isn’t ready” and “you’ll be waiting a while.” But early access? That signals exclusivity, priority, and that you’re getting something before everyone else.

The mechanics are identical. The experience is different. When you’re answering Claude’s questions about the CTA, push it toward framing like:

- “Get early access”
- “Join the founding members”
- “Be first in line”

Avoid: “Join the waitlist,” “sign up to wait,” “we’ll let you know when it’s ready.”

This is one of those things that sounds minor but has a real impact on how people feel about clicking that button.

---

## 7\. Try It Yourself

### Exercise 1: Get the Page Built

**What to do:** Clone the starter repo, drop your Module 2 documents into `.sales`, run the prompt, answer the questions, and get your first version of the landing page generated.

**A nudge if you’re stuck:** If Claude’s output looks too generic after the first pass, run the follow-up prompt about non-common fonts and making the page pop. That alone usually makes a significant difference.

**How you’ll know it’s working:** You can open `index.html` in WebStorm and see a complete, styled landing page in the browser preview.

### Exercise 2: Iterate with Screenshots

**What to do:** Find something in your page that doesn’t look quite right, an alignment issue, a section that feels off, a logo or heading you don’t love. Take a screenshot of it, paste it into Claude Code, and tell Claude what you want changed.

**What this is practising:** The feedback loop that you’ll use constantly throughout the Build module. Getting comfortable with screenshot-driven iteration will save you hours.

---

## 8\. You Should Be Able to Build This Now

Here’s what you can put together with what we just covered:

- A fully styled landing page for any product, pre-launch or live
- A waitlist page with pricing, social proof, and a competitor-informed value proposition

### Check Yourself

- I’ve cloned the starter repo and have it open in WebStorm
- My Module 2 documents are in the `.sales` folder
- I’ve run Claude Code with the correct model and MCP config flags
- I’ve answered Claude’s clarifying questions and have a first version of the page
- I’ve previewed the page in the browser, desktop and mobile
- I’ve done at least one round of screenshot-based iteration

✅

If you’re ticking those boxes, you’re ready for the next lesson, where we connect the email input to ConvertKit so the waitlist actually captures signups.

### If Something’s Not Working

⚠️

****Git / GitHub not showing in WebStorm**  
****What’s happening:** Git isn’t installed or configured on your machine, so WebStorm can’t clone from GitHub.  
****How to fix it:** Install git from [git-scm.com](https://git-scm.com/?ref=deletosh.com), configure your GitHub credentials, then restart WebStorm. Detailed steps are in the Resources section below. If you’re still stuck, ask in Discord.

⚠️

****Claude Code command not found**  
****What’s happening:** Claude Code isn’t installed or isn’t on your PATH.  
****How to fix it:** Go back to Module 3, Lesson 3, Installing Claude Code, and follow the setup steps again. Once it’s installed, close and reopen your terminal.

⚠️

****The page looks empty or broken in the browser preview**  
****What’s happening:** Claude may have hit an error mid-generation and the HTML file is incomplete.  
****How to fix it:** Scroll back through Claude Code’s output and look for any error messages. If you see something about a tool error or incomplete file, just ask Claude to “fix any errors and complete the page.” It’ll usually self-correct.

---

## The Short Version

Here’s what I want you to walk away with:

- **The landing page comes first:** Get something online before the app is done. Validate demand, collect signups, talk to early users while you build.
- **Your documents are your context:** The research and planning from Module 2 isn’t just busywork, it’s the input that makes Claude’s output actually relevant to your product.
- **Iterate with screenshots:** Claude can’t see your browser. Screenshots close the gap. Take one, paste it, say what’s wrong. Repeat until it’s right.
- **Never call it a waitlist:** Frame it as early access. Same thing, completely different experience.

---

## Quick Reference

### Claude Code Command

```
claude --model claude-opus-4-6 --mcp-config .mcp.json

```

### First Prompt

```
Review my app info in the .sales directory. Based on this, use the frontend-design skill to research my competition and design a standout landing page.

Before you design, ask me all the clarifying questions you need.

```

### Design Follow-up Prompt

```
Update the design to make the page pop a bit more and not look generic. Use non-common font pairings and introduce elements that will be relevant to our prospects.

```

### Screenshot Paste Shortcut (Claude Code terminal)

```
Ctrl+V   ← paste image into Claude Code prompt (use Ctrl, not Command, even on Mac)

```

---

## Resources

### Links & Docs

- [Starter Repo](https://github.com/deletosh/tpp-landing-page-starter?ref=deletosh.com)clone this to get started *(referenced in Module 4, Lesson 1)*
- [Git Download](https://git-scm.com/downloads?ref=deletosh.com)if git isn’t installed on your machine
- [CleanShot (Mac)](https://cleanshot.com/?ref=deletosh.com)screenshot tool used in the video
- [ShareX (Windows)](https://getsharex.com/?ref=deletosh.com)screenshot tool alternative for Windows
- [WebStorm](https://www.jetbrains.com/webstorm/?ref=deletosh.com)IDE used throughout the course

### Tools Used

- [Claude Code](https://www.anthropic.com/claude-code?ref=deletosh.com)
- [WebStorm](https://www.jetbrains.com/webstorm/?ref=deletosh.com)

---

## Questions I Get Asked

**Q: Do I really need all four documents in the `.sales` folder?**

At a minimum, I’d say yes to all four: GTM, Market Research, Summary, UX/UI. Each one gives Claude a different dimension of context. Without the UX/UI doc, it won’t know your colour palette. Without the market research, it won’t know who your competitors are. The more context it has, the more tailored the output.

**Q: Can I use VS Code instead of WebStorm?**

Yes. WebStorm is my personal preference because of how it handles the terminal and file browser together, but everything we’re doing works fine in VS Code. The only difference is keyboard shortcuts and where the terminal panel lives.

**Q: What if I don’t like what Claude generates even after a few rounds of iteration?**

That’s a signal to be more specific in your prompts, not to give up. Take a screenshot of exactly what you don’t like, describe the specific problem (alignment, font, colour, layout), and ask Claude to address that one thing. Fixing everything in one prompt rarely works well, targeted, specific feedback gets better results.

**Q: How do I know I’m ready for the next lesson?**

If you have a working `index.html` that you can open in the browser and it looks like a real landing page, with a CTA, pricing section, and some social proof, you’re good. The email form won’t work yet; that’s what Module 4, Lesson 2 is for.

---

## 💬 Stuck? Come Talk to Us

💡

If something’s not clicking or you want to share what you’ve built, come find us in Discord.  
****Build What Ships community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community’s active and I check in there too.

---

## Glossary

**Claude Code:** The command-line version of Claude, designed to operate directly inside your codebase. More powerful than Claude Desktop for development tasks because it can read, write, and run files in your project. *(first introduced in Module 3, Lesson 3 - Installing Claude Code)*

**Frontend-design skill:** A set of specialized instructions loaded from the `.claude/skills/` folder that gives Claude expert knowledge about landing page design, typography, layout, conversion principles, and visual differentiation. *(first used in Module 4, Lesson 1)*

**`.sales` folder:** A project directory that holds your product documents (GTM, market research, etc.) so Claude has the right context when generating your landing page. *(introduced in Module 4, Lesson 1)*

**MCP (Model Context Protocol):** The integration layer that lets Claude connect to external tools and services. In this lesson, we’re using it to give Claude access to Vercel (used in a later lesson). *(first introduced in Module 2, Lesson 4 - Generating the UX/UI Document)*

**Waitlist framing:** The practice of positioning a pre-launch email capture as “early access” or “founding member” rather than “join the waitlist”, same mechanic, completely different experience for the user. *(introduced in Module 4, Lesson 1)*

**Wordmark:** A logo that uses only styled text, the company or product name, with no icon or symbol. Simpler to implement and often cleaner for early-stage products. *(mentioned in Module 4, Lesson 1)*

**Micro-interactions:** Small visual responses to user actions, like a button changing colour on hover, or an element animating into view as you scroll. They make a page feel polished and intentional. *(referenced in Module 4, Lesson 1)*
### Module 3, Lesson 9: Scoping the GTM Project in YouTrack
URL: https://deletosh.com/courses/product-path/03-09-scope-gtm-youtrack/
Last updated: 2026-07-16T15:33:47.000Z
## How do you scope a GTM project in YouTrack with Claude?

You scope a GTM project by pointing Claude Desktop at your market research and GTM documents in the Co-Work tab, where it can use your MCP connections, and ending your prompt with an instruction to ask clarifying questions first, about scope, structure, assignment, and dates, before it creates anything.

Answering those questions upfront is what makes the output a usable board instead of a generic list. Claude then generates the Epics, milestones, and sub-tasks directly in your YouTrack GTM project for you to review.

**The short version: you let Claude ask clarifying questions first, about scope, structure, assignment, and dates, then it generates the epics, milestones, and tasks as a YouTrack board. Answering upfront is what makes the output usable instead of generic. The full prompt and review are inside The Product Path.**

In this lesson, I'm putting that fresh Claude Desktop + YouTrack connection to work. We take the market research and GTM document we created all the way back in Module 2, point Claude at them, and let it scope out the entire go-to-market project, Epics, milestones, sub-tasks, context, due dates and all, directly in YouTrack.

ℹ️

This lesson uses the ****Co-Work tab** in Claude Desktop, not a standard Chat session. Make sure you're in the right place before you start the prompt.

---

## Before We Start

Here's what I'd expect you to have under your belt before this lesson:

**From previous lessons:**

- Claude Desktop is connected to YouTrack via the MCP config we set up in Module 3, Lesson 8, you've tested the connection and it works
- You have a GTM project already created in YouTrack with a project ID (mine is `NGTM`yours will be whatever you named it)
- Your market research document and GTM document exist in your Obsidian vault (or wherever you stored them), these are the two inputs Claude needs
- You know how to find your YouTrack project ID (it shows up right on the project page)

**Tools / setup you'll need:**

- Claude Desktop, local version, Co-Work tab open
- YouTrack, free tier, your GTM project already created
- Your Obsidian vault (or equivalent) accessible with the market research and GTM docs inside

**By the end of this lesson, you'll:**

- Have a fully scoped GTM project in YouTrack with Epics, milestones, and child tasks
- Understand how to use the clarification loop to make sure Claude understands your intention before it creates anything
- Know how to review what Claude created and where to clean things up manually

---

## About This Lesson

**Duration:** \~11 minutes video  
**Skill Level:** Intermediate  
**What You'll Build:** A fully structured GTM Agile board in YouTrack, Epics, milestones, and sub-tasks drawn from your real market research and GTM documents

This is one of those moments where everything we've been building toward snaps together. All those documents we generated in Module 2? They're not just reference material sitting in a folder. They're the raw input that populates your actual project board. This lesson is short in video time but punchy in output, by the end you'll have your GTM completely mapped out as trackable work.

---

## Watch the Lesson

---

ℹ️

****How I'd suggest going through this:** Watch the video first without stopping, it's short, just follow along and get the shape of it. Then come back here and use the prompt template and the step-by-step walkthrough to do it yourself. This guide is your working reference, you shouldn't need to rewatch to look something up.

---

## What Will This Lesson Cover?

Here's what I'm walking you through in this lesson:

- **The prompt pattern**: why I ask Claude to ask me questions *before* it creates anything, and how that saves you from a mess
- **Answering Claude's clarifying questions**: the specific decisions you'll need to make (structure, assignment, dates)
- **Reviewing the output**: what a well-scoped GTM board looks like and what still needs a human touch
- **The wrap-up**: where this leaves you at the end of Module 3

---

## 1\. Let's Set the Scene *(\~0:00)*

I've already confirmed that Claude Desktop connects to YouTrack, we did that in Lesson 8\. Now it's time to actually use it.

What I want to do here is take two documents, my market research and my GTM document, and use them as the source of truth for scoping out a complete GTM project in YouTrack. Not a rough list of tasks, but a properly structured board with Epics, milestones, and sub-tasks that a small team can actually pick up and run with.

I do this in the **Co-Work tab**, not in a standard chat. That distinction matters, Co-Work is where Claude can use your MCP connections and contents of your folders to take actions (like writing to YouTrack), whereas Chat is for conversation only.

---

## 2\. The Core Idea

### 2.1 Why Ask Claude Questions First

Here's a pattern I use a lot that I want you to borrow: I end my prompt with *"before you write, ask me all the questions you have for clarification."*

That one line does a lot. It forces Claude to surface its assumptions before it acts on them. And when you see the questions it comes back with, you immediately know whether it understood your intention or whether it's about to go off in the wrong direction.

The first time I ran this prompt in the video, Claude came back and asked about splitting things across two separate projects, which wasn't what I wanted at all. Because I'd asked it to clarify first, I caught that before it created a bunch of issues in the wrong place. I just updated the prompt, ran it again, and the second round of questions was much better.

ℹ️

Think of the clarification loop like a quick briefing before a meeting. You don't want to get 20 minutes in before you realise everyone showed up with a different agenda.

### 2.2 How This Connects to [Module 3, Lesson 7](https://deletosh.com/courses/the-product-path/03-07-build-project-youtrack/) \- Building Out the Project

In Lesson 7 we used Claude Code to scope out the dev project in YouTrack. Same idea here, except now we're using Claude Desktop (via Co-Work), and we're scoping the GTM work instead of the development work. Two projects, same approach. By the end of this lesson, both sides of your work, product and go-to-market, are tracked.

---

## 3\. The Prompt *(\~1:05)*

Here's the prompt I use. Drop this into your Co-Work tab, swap in your product name and project ID, and you're off.

```
Review the following in my folder:
- App - [Your Product Name] - Market Research
- App - [Your Product Name] - GTM

Using the YouTrack tool, create all the relevant issues in my GTM project, [YOUR-PROJECT-ID].
This project will contain all my key GTM tasks. I'm a team of [1 or 2].

Here is additional context:
- Add all the context each issue needs for the team to complete the task
- When needed, pull additional context / latest info with the web search tool

Before you write, ask me all the questions you have for clarification.

```

A few things to fill in before you run it:

- **`[Your Product Name]`**match this exactly to how your files are named in Obsidian (or wherever you store them)
- `**[YOUR-PROJECT-ID]**`find this on your YouTrack project page. Mine is `NGTM`. Yours will be whatever short ID YouTrack assigned or you set when creating the project
- **`[1 or 2]`**your team size. Claude uses this to make decisions about assignment and workload distribution

⚠️

****Don't skip the "ask me questions first" line.** I tried running it without this once and Claude went ahead and created issues based on its own assumptions. Getting it to ask first costs you maybe two minutes. Skipping it can cost you a lot more in cleanup.

---

## 4\. Answering Claude's Clarifying Questions *(\~2:21)*

Once you run the prompt, Claude will come back with a set of questions. Here's what mine asked, and how I answered:

### Scope: full plan or just the first few weeks?

Claude asked whether I wanted it to scope out the full GTM plan or just the near-term tasks. I went with the **full plan**. The point of this exercise is to get everything on the board so nothing falls through the cracks, I can always break it into sprints later.

### Structure: flat list, or Epics + milestones + child tasks?

I always go with **Epics, milestones, and child tasks**. A flat issue list might feel simpler, but it gets unmanageable fast. Grouping tasks under Epics gives you a clear sense of what each channel or initiative looks like as a whole before you zoom in.

### Assignment: assign to team members, or leave unassigned?

Claude asked whether to assign issues to the two team members. I left everything **unassigned**I'd rather do a manual review pass and assign things deliberately than have Claude make calls it doesn't have enough context for. Dates and ownership are the two things I almost always handle myself after the initial generation.

### Due dates: set them or leave blank?

I told Claude to add due dates starting from the following week (today was March 12, 2026, so that meant March 16 as the starting point). One thing I want to flag here: **Claude gets dates wrong fairly often.** I treat any dates it sets as a rough draft, a starting point I'll edit manually once I've reviewed the full board. If you have firm dates in mind, go ahead and give them explicitly. If not, just let it estimate and clean them up afterwards.

⚠️

****Claude and dates.** This one's worth calling out explicitly. AI tools generally aren't reliable with precise scheduling and sequencing, they don't have a real sense of what's achievable in a week. Use the dates as scaffolding, not gospel. Review and adjust them once you can see the full board.

---

## 5\. What Claude Creates *(\~6:15)*

After you answer the questions and let Claude run, it'll work through your documents, pull web context where relevant, and start creating issues in YouTrack. You'll see it asking for permission each time it calls the YouTrack tool, keep clicking Allow.

When it finishes, Claude will give you a summary. Mine came back with **13 Epics/milestones and 30+ child tasks**: the full GTM plan, scoped, structured, and written with enough context that someone picking up a task for the first time could actually understand what to do.

Here's what each issue looks like when you open it:

- **Description**: what this Epic or task is about, tied back to your market research and GTM strategy
- **Competitive context**: for channel-level Epics, Claude pulls in what competitors are doing in that space so you know what you're up against
- **Sub-tasks**: concrete actions with enough detail to get started (e.g. "Use Ubersuggest to build a 10-article content cluster around \[keyword category\]")
- **Due date**: rough estimate you'll want to review
- **Status and time tracking fields**: left blank for you to fill in as work progresses

The amount of context per issue is what makes this useful. This isn't just a list of task names, it's a brief for each piece of work.

💡

One thing I added to the prompt that's worth noting: I asked Claude to pull fresh web context as it created each issue. That means even though our original research was done a few weeks earlier, the issues it writes are drawing on current information, not just what we captured at research time. Small thing, but it keeps the context sharp.

---

## 6\. Reviewing the Output in YouTrack *(\~7:39)*

Once it's done, head into YouTrack and refresh. Here's how I check the work:

1. **Go to your GTM project** and open the issue list, you'll see all the Epics collapsed
2. **Click into one Epic** to see its description and child tasks, check the context makes sense for your product
3. **Switch to the Agile board view** (Agile Boards in the sidebar), this gives you the Kanban-style layout and lets you see how Claude has grouped things

You'll likely find that some tasks are grouped sensibly and others need a bit of tidying. That's normal and expected, Claude does the heavy lifting, you do the editorial pass. The Agile board view is the best place to do that cleanup because you can see everything at once.

---

## 7\. Try It Yourself

### Exercise 1: Run the Prompt

**What to do:** Take the prompt template from Section 3, fill in your product name, project ID, and team size, and run it in your Co-Work tab. Don't skip the "ask me questions" line.

**A nudge if you're stuck:** If Claude doesn't seem to be finding your documents, double-check that the document names in your prompt match exactly what's in Obsidian (or your note tool). Case and spacing matter.

**How you'll know it's working:** Claude comes back with clarifying questions rather than immediately creating issues.

### Exercise 2: Review and Clean Up

**What to do:** Once Claude has created the issues, open three different Epics and read through the descriptions and sub-tasks. Check: does this make sense for your product? Are there obvious gaps or things that don't apply?

**What this is practising:** The human review step. This is where you add judgment that Claude can't supply, what actually matters for *your* specific market, timing, and team.

---

## 8\. You Should Be Able to Build This Now

Here's what you can put together with what we just covered:

- A fully structured GTM project board in YouTrack from your existing research and strategy documents
- A repeatable prompt pattern you can use to scope any project in YouTrack, not just GTM

### Check Yourself

- I ran the prompt and got Claude's clarifying questions back before any issues were created
- I answered the questions and Claude created the full issue set in my YouTrack GTM project
- I've reviewed at least three issues and confirmed the context looks right for my product
- I understand which things (dates, assignments) I need to clean up manually

✅

If you're ticking those boxes, that's Module 3 done. You've gone from raw research to a fully scoped, fully tracked project. That's not a small thing. Nice work.

### If Something's Not Working

⚠️

****Claude can't find my documents**  
****What's happening:** The document names in your prompt don't match the actual file names in Obsidian (or your note tool).  
****How to fix it:** Open your vault, copy the exact file name, and paste it into the prompt. Even a small mismatch ("Market Research" vs "Market-Research") will cause it to miss.

⚠️

****Issues are being created in the wrong project**  
****What's happening:** Your YouTrack project ID in the prompt doesn't match the actual ID in YouTrack.  
****How to fix it:** Go to your YouTrack project page, the project ID is shown right there. Copy it exactly (it's usually a short all-caps string like NGTM or MYPROJ) and update your prompt.

⚠️

****Claude went straight to creating issues without asking questions**  
****What's happening:** The clarification line was either missing from your prompt or Claude interpreted it as optional.  
****How to fix it:** Stop the run, add "Before you write, ask me all the questions you have for clarification" as the last line of your prompt, and run it again. If issues were already created in the wrong structure, delete them from YouTrack and start fresh.

---

## The Short Version

Here's what I want you to walk away with:

- **The clarification loop is your safety net:** Always ask Claude to ask you questions before it creates anything. It's the fastest way to confirm you're both on the same page.
- **Structure beats flat lists:** Epics → milestones → child tasks is harder to set up but infinitely easier to manage once you're in execution mode.
- **Dates and assignments are yours to own:** Claude will estimate them, but treat those as a draft. Review and assign manually.
- **What you can do now:** Your GTM is scoped and tracked. You know what needs to happen, in what order, and you have a board you can actually work from.

---

## Quick Reference

### The Prompt Template

```
Review the following in my folder:
- App - [Your Product Name] - Market Research
- App - [Your Product Name] - GTM

Using the YouTrack tool, create all the relevant issues in my GTM project, [YOUR-PROJECT-ID].
This project will contain all my key GTM tasks. I'm a team of [1 or 2].

Here is additional context:
- Add all the context each issue needs for the team to complete the task
- When needed, pull additional context / latest info with the web search tool

Before you write, ask me all the questions you have for clarification.

```

### Clarifying Questions: How I Answered Mine

| Question                                              | My Answer                                                 |
| ----------------------------------------------------- | --------------------------------------------------------- |
| Full plan or near-term only?                          | Full plan                                                 |
| Flat list or structured (Epics + milestones + tasks)? | Epics, milestones, and child tasks                        |
| Assign to team members or leave unassigned?           | Leave unassigned — I'll assign manually                   |
| Set due dates?                                        | Yes — use next week as the starting date (treat as draft) |

### Finding Your YouTrack Project ID

Go to your YouTrack project → the project ID is displayed on the project overview page. It's the short uppercase string (e.g. `NGTM`, `DEV`, `MYAPP`).

---

## Resources

### Tools Used

- [YouTrack](https://www.jetbrains.com/youtrack/?ref=deletosh.com)project management, free tier
- [Claude Desktop](https://claude.ai/download?ref=deletosh.com)Co-Work tab, with YouTrack MCP connected (set up in Module 3, Lesson 8)
- [Obsidian](https://obsidian.md/?ref=deletosh.com)where the market research and GTM documents live (or your equivalent note tool)

---

## Questions I Get Asked

**Q: Do I need to use Co-Work, or can I just use the regular Chat tab?**

You need Co-Work for this. Regular Chat doesn't have access to your MCP connections, it can't call the YouTrack tool and create issues. Co-Work is where Claude can actually take actions.

**Q: Claude created way more issues than I expected. Is that a problem?**

Not necessarily. Review them and delete anything that doesn't apply. It's easier to prune a comprehensive list than to start over from a sparse one. Just go through the board, collapse what you don't need now, and archive anything irrelevant.

**Q: How do I know I'm ready for the next module?**

If you have a dev project board and a GTM project board in YouTrack, both scoped, both populated, both making sense for your specific product, you're ready. That's what Module 3 was building toward. The next step is shipping.

---

## 💬 Stuck? Come Talk to Us

💡

If something's not clicking or you want to share what you've built, come find us in Discord.  
****Build What Ships community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community's active and I check in there too.

---

## Glossary

**Co-Work:** The tab in Claude Desktop where Claude can use your connected MCP tools to take real actions, write to files, create issues, call APIs. Different from Chat, which is conversation only. *(first came up in Module 3, Lesson 8 - Connecting Claude Desktop to YouTrack)*

**Epic:** A high-level work item in YouTrack (and most Agile tools) that groups related tasks under a single goal or initiative. *(first came up in Module 3, Lesson 7 - Building Out the Project)*

**MCP (Model Context Protocol):** The system that lets Claude Desktop connect to external tools, YouTrack, Figma, Obsidian, and others, so it can take actions beyond the chat window. *(first came up in Module 2, Lesson 4 - Generating the UX/UI Document)*

**Project ID:** The short identifier YouTrack uses to reference a project (e.g. `NGTM`). Used in API calls and MCP tool integrations to tell Claude which project to write to. *(first came up in Module 3, Lesson 6 - Setup Claude Code + YouTrack)*

**RICE Scoring:** A prioritisation framework, Reach, Impact, Confidence, Effort, used in Module 3, Lesson 4 to rank features before building the implementation roadmap. *(first came up in Module 3, Lesson 4 - Designing RICE)*
### Module 3, Lesson 8: Connecting Claude Desktop to YouTrack
URL: https://deletosh.com/courses/product-path/03-08-connect-claude-desktop-youtrack/
Last updated: 2026-07-16T15:33:46.000Z
## How do you connect Claude Desktop to YouTrack?

You connect Claude Desktop to YouTrack by manually editing the claude\_desktop\_config.json file to add a YouTrack MCP server, supplying your YouTrack instance URL and an API token, then restarting Claude Desktop and running a quick test.

This is a separate connection from the Claude Code plus YouTrack setup, and it is meant for non-dev work: managing GTM, sales, and marketing tasks in plain language. In this lesson you also create a second YouTrack project so business work lives apart from the development board.

**The short version: you link Claude Desktop to YouTrack through an MCP connection, so you can plan, scope, and update your board using plain language instead of clicking around. It turns project management into a conversation. The full connection setup is inside The Product Path.**

In this lesson, I'm connecting Claude **Desktop** to YouTrack, a separate connection from the Claude Code + YouTrack setup we did in Lesson 6\. This one's specifically so we can manage non-dev work (GTM, sales, marketing tasks) from Claude Desktop. By the end, we'll have YouTrack connected, tested, and ready to start scoping the GTM project in the next lesson.

ℹ️

The MCP config snippet you need is in the Quick Reference at the bottom. Don't type it from scratch, copy it, swap in your YouTrack username and token, and you're done.

---

## Before We Start

Here's what I'd expect you to have under your belt before this lesson:

**From previous lessons:**

- Your development project board is already set up in YouTrack (Module 3, Lesson 7)
- You've used Claude Desktop before and understand what MCP integrations do, we covered that in Module 2 (Figma) and Module 3, Lesson 1 (JetBrains)
- Claude Code is already connected to YouTrack from Module 3, Lesson 6, this is a *separate* connection for Claude Desktop

**Tools / setup you'll need:**

- Claude Desktop app (the local desktop version, not the web/browser version)
- A text editor for editing JSON files, Sublime Text, VS Code, or even Notepad will do
- Your YouTrack instance URL (e.g. `yourusername.youtrack.cloud`)
- A YouTrack API token, I'll show you how to create one if you don't have it handy

**By the end of this lesson, you'll:**

- Know how to manually add an MCP integration to Claude Desktop by editing the config file
- Have YouTrack connected to Claude Desktop and confirmed as working
- Have a second YouTrack project set up for GTM and product management work (separate from the dev project)

---

## What Is This Lesson About?

**Duration:** \~12 minutes video + \~15 minutes to set up on your own machine  
**Skill Level:** Intermediate  
**What You'll Build:** A working YouTrack MCP connection inside Claude Desktop, tested and ready for the GTM scoping session in the next lesson

This lesson is a short but important setup step. We're separating dev work from non-dev work in YouTrack, two projects, two audiences, one tool. Claude Desktop handles the business side; Claude Code handles the build side. Getting this wired up now means the next lesson can move fast.

---

## Watch the Lesson

---

ℹ️

****How I'd suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide step by step. The config snippet in Quick Reference is exactly what you need, copy from there, don't retype it.

---

## What We're Covering

Here's what I'm walking you through in this lesson and why it matters:

- **Why a separate GTM project**: the dev board and the GTM board serve different people; they shouldn't live in the same place
- **Setting up the YouTrack project**: creating a product management project and making sure the right custom fields are there
- **Manually editing the Claude Desktop config**: how to add an MCP server by editing `claude_desktop_config.json` directly
- **Replacing your username and token**: the two things you actually need to change
- **Creating or regenerating your API token**: what to do if you can't find the one you made before
- **Testing the connection**: a quick smoke test to confirm it's actually working before we trust it with real work

---

## 1\. Let's Set the Scene *(\~0:00)*

We already have our development project in YouTrack, Epics, User Stories, the whole board. That's the technical side of the product. But if you're building something real, there's a whole other stream of work running alongside that: marketing, sales, launch planning, content, GTM campaigns. That stuff deserves to be tracked properly too.

In this lesson, we're going to create a separate YouTrack project specifically for that non-dev work. And then we're going to connect Claude Desktop to YouTrack so it can read and write to that project directly.

If you're planning to hand the dev work off to someone else and focus on the product and go-to-market side yourself, this is the setup you need. Or if you're wearing both hats, you'll want both connections running.

Either way, the dev project stays as-is. We're not touching it. We're adding a second project and a new connection.

---

## 2\. Create the GTM Project in YouTrack *(\~0:45)*

First, let's create the new project before we touch any config files.

In YouTrack, go to **Projects → New Project**. For the template, choose **Product Management**: this is the important bit. When you pick Product Management, YouTrack will automatically set up custom fields for Estimate, Spent Time, and Due Date. You want those. The dev project we created before didn't need them, but for task and milestone tracking on the GTM side, they're useful.

Give your project a name that makes sense for your product. In my case, I named mine after the product with a "GTM" marker to make it obvious what it is. I also gave it a short ID, I used `NGTM`because you'll reference that ID in prompts later.

Once it's created, go to **Custom Fields** and confirm you see Estimate, Spent Time, and Due Date listed. If they're there, you're good to go.

ℹ️

The key difference between the Product Management template and a default project is those time-tracking fields. For dev work, we tracked things by story points and acceptance criteria. For GTM tasks, things like "write a launch email sequence" or "publish three case studies", actual time estimates matter a lot more.

---

## 3\. Add YouTrack to Claude Desktop *(\~1:50)*

Now for the actual connection. Here's the thing: YouTrack doesn't have a built-in integration option inside Claude Desktop the way some other tools do. So we're adding it manually by editing a JSON config file. It sounds more complicated than it is, you're literally just adding a block of text to a file.

### 3.1 Open the Config File

In Claude Desktop, click your **profile icon** (sidebar, top or bottom depending on your version), go to **Settings**, then **Developer**. You should see your current MCP integrations listed there, you'll have Filesystem at minimum, and if you've been following along, JetBrains should be there too.

Click **Edit Config**. This will open your file manager and navigate you to the folder containing `claude_desktop_config.json`. Double-click that file to open it in a text editor. If nothing opens it automatically, right-click and choose to open it with VS Code, Sublime Text, or Notepad, whichever you have.

⚠️

On Windows, the path to this file is slightly different from Mac. The Edit Config button will take you there regardless, just let it navigate you, then open the file from wherever it lands.

### 3.2 Understand the File Structure

When you open it, you'll see JSON, curly braces, key-value pairs, indentation. Don't worry if it looks foreign. You don't need to understand all of it. The structure looks roughly like this:

```json
{
  "mcpServers": {
    "jetbrains": {
      ...existing config...
    }
  }
}

```

Each MCP integration is a named block inside `"mcpServers"`. We're going to add a new block for YouTrack alongside the existing ones.

### 3.3 Add the YouTrack Block

Find the closing `}` of the last existing server entry. After it (but still inside `"mcpServers"`), add a comma, then paste the YouTrack config block.

The config I use is in the **Quick Reference** section at the bottom, copy it from there. Once you've pasted it, there are exactly **two things to replace**:

1. `**<username>**`replace with your YouTrack subdomain. If your YouTrack URL is `deletosh.youtrack.cloud`, your username is `deletosh`.
2. **`<token>`**replace with your API token (covered in the next step).

That's it. Everything else in that block stays exactly as-is.

---

## 4\. Get Your YouTrack API Token *(\~5:30)*

The token is how YouTrack knows that Claude Desktop is allowed to read and write to your account. If you created one during the Claude Code + YouTrack setup in Module 3, Lesson 6, you can reuse that one, just paste it in.

If you don't have it handy (or you'd rather create a fresh one for Claude Desktop specifically), here's how:

1. In YouTrack, click your **profile avatar** (top right)
2. Go to **Account Security**
3. Scroll to **Tokens**: you'll see any you've already created
4. Click **New Token**, give it a name (I called mine "Claude Desktop"), and click **Create**
5. Copy the token immediately, you won't be able to see it again after you close that modal

Once you have it, go back to your text editor and replace `<token>` in the config file with the token you just copied.

⚠️

YouTrack only shows you the token value once, right after creation. If you forget to copy it and close the modal, you'll need to delete it and create a new one. Just name it something memorable so you know what it's for.

---

## 5\. Save, Quit, and Restart Claude Desktop *(\~6:30)*

Once you've made your edits, save the file, `Cmd+S` on Mac, `Ctrl+S` on Windows.

Now you need to **fully quit Claude Desktop**: not just close the window, but quit the application entirely. On Mac: right-click the dock icon → Quit. On Windows: right-click the taskbar icon → Exit. Then reopen it.

This matters. Claude Desktop reads the config file on startup. If you don't restart it, it won't pick up the new integration.

Once it's back open, go to **Settings → Developer** again and look for YouTrack in the list. If you see it and it shows as **running**, the connection is live.

✅

The green "running" indicator next to YouTrack in Developer settings is your signal that the MCP server launched successfully. If it shows an error, the most common cause is a typo in the JSON, check that all your brackets, commas, and quotes are correct.

---

## 6\. Test the Connection *(\~7:20)*

Don't trust the green indicator alone. Let's actually test that it can read and write.

Open a new chat in Claude Desktop. Type something like:

```
Using the YouTrack tool, show me the issues in my [YOUR-PROJECT-ID] project.

```

Replace `[YOUR-PROJECT-ID]` with the short ID you gave your GTM project (I used `NGTM`).

Claude Desktop will ask if it can use the YouTrack tool, click **Allow**. If all is well, it'll come back with something like "the project has no issues." That's fine, we haven't added any yet. The point is it found the project and got a response without an error.

If you want a more definitive test, ask it to **create a sample issue** in the project:

```
Create a sample issue in my [YOUR-PROJECT-ID] project.

```

Allow it to use the tool again. Then go to YouTrack, open your GTM project, and refresh the page. You should see a draft issue sitting there. That's your confirmation it's working end to end.

ℹ️

The test issue will probably land as a Draft, not a live issue. That's expected, YouTrack's API creates issues in draft state by default when using MCP. You can submit it manually or just delete it; it served its purpose as a test.

---

## 7\. Why Claude Desktop Here, Not Claude Code?

I want to briefly explain the split, because it might not be obvious.

**Claude Code** is your development tool. It lives in your terminal, it has access to your project files, and it's optimised for writing and editing code. That's why we used it to build the dev board in YouTrack, it can read your spec files, cross-reference your roadmap, and write technically precise issues.

**Claude Desktop** is your general-purpose tool. It's connected to Obsidian, Figma, and now YouTrack, but it's not sitting inside your codebase. For GTM and product management tasks, that's actually what you want. You're not writing implementation tickets. You're writing campaign tasks, launch milestones, sales outreach plans. Claude Desktop, with access to all your product documents via Obsidian, is better suited for that.

The two connections, Claude Code → YouTrack and Claude Desktop → YouTrack, can coexist. They both use the same YouTrack instance; they just live in different tools and serve different workflows.

---

## 8\. You Should Be Able to Build This Now

Here's what you can put together with what we just covered:

- A working YouTrack MCP integration in Claude Desktop, installed manually via the config file
- A separate GTM/product management project in YouTrack, ready to receive tasks from the next lesson

### Check Yourself

- I've created a Product Management project in YouTrack (with Estimate, Spent Time, and Due Date fields)
- I've edited `claude_desktop_config.json` and added the YouTrack MCP block
- I've restarted Claude Desktop and see YouTrack listed as "running" in Developer settings
- I've tested it by creating or listing an issue and confirmed it worked

✅

If you're ticking those boxes, the connection is live and you're ready for the next lesson, where we actually use this to scope out the full GTM project in YouTrack.

### If Something's Not Working

⚠️

****YouTrack doesn't appear in Developer settings after restart**  
****What's happening:** Most likely a JSON syntax error in the config file, a missing comma, an unclosed brace, or a stray character.  
****How to fix it:** Open `claude_desktop_config.json` again and check the structure carefully. Every server block inside `mcpServers` should be separated by a comma. Paste the whole file into a JSON validator (e.g. jsonlint.com) to find the error quickly.

⚠️

****YouTrack appears but shows an error, not "running"**  
****What's happening:** The config was parsed correctly, but the connection failed, usually because the username or token is wrong.  
****How to fix it:** Double-check that your username matches your YouTrack subdomain exactly (no angle brackets left in), and that the token is complete with no extra spaces. If in doubt, generate a fresh token and paste it in again.

⚠️

****The test issue isn't showing up in YouTrack**  
****What's happening:** It might have been created as a draft and not submitted. Or the wrong project ID was used.  
****How to fix it:** In YouTrack, check for draft issues, they sometimes don't appear in the main board view. Also confirm the project ID in your test prompt matches exactly what's in YouTrack (it's case-sensitive).

---

## The Short Version

Here's what I want you to walk away with:

- **Claude Desktop ≠ Claude Code.** Two separate tools. Both can connect to YouTrack, but for different workflows. Desktop for GTM and product tasks; Code for dev.
- **The config file is just JSON.** Editing it manually sounds scary but it's just adding one block of text. Two values to replace: your username and your token.
- **Always fully quit and relaunch.** Claude Desktop reads config on startup. Closing the window isn't enough.
- **What you can do now:** In the next lesson, we're using this connection to scope the entire GTM project in YouTrack, same approach we used for the dev board, just focused on the go-to-market side.

---

## Quick Reference

### The MCP Config Block

Add this inside the `"mcpServers"` object in your `claude_desktop_config.json`. Replace `<username>` with your YouTrack subdomain and `<token>` with your API token:

```json
"youtrack-prt": {
  "command": "npx",
  "args": [
    "mcp-remote",
    "https://<username>.youtrack.cloud/mcp",
    "--header",
    "Authorization:${AUTH_HEADER}"
  ],
  "env": {
    "AUTH_HEADER": "Bearer <token>"
  }
}

```

### What Your Full Config Should Look Like

Your `mcpServers` block should look something like this after adding YouTrack (your existing entries will differ):

```json
{
  "mcpServers": {
    "filesystem": {
      ...
    },
    "jetbrains": {
      ...
    },
    "youtrack-prt": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://<username>.youtrack.cloud/mcp",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer <token>"
      }
    }
  }
}

```

Each server entry needs to be separated by a comma. The last entry before the closing `}` of `mcpServers` should **not** have a trailing comma.

### Where to Find the Config File

- **Mac:** `~/Library/Application Support/Claude/claude_desktop_config.json`
- **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`

The easiest way to get there is via Claude Desktop → Settings → Developer → Edit Config.

### How to Create a YouTrack API Token

1. Profile avatar → **Account Security**
2. Scroll to **Tokens**
3. Click **New Token** → name it (e.g. "Claude Desktop") → **Create**
4. Copy the token immediately, it won't be shown again

### Quick Smoke Test

Once connected, paste this in a new Claude Desktop chat:

```
Using the YouTrack tool, show me the issues in my [YOUR-PROJECT-ID] project.

```

If it responds (even to say the project is empty), you're connected.

---

## Resources

### Links & Docs

- [YouTrack API Tokens documentation](https://www.jetbrains.com/help/youtrack/server/manage-permanent-token.html?ref=deletosh.com)how to create and manage permanent tokens
- [Claude Desktop MCP configuration guide](https://support.claude.com/en/articles/10949351-getting-started-with-local-mcp-servers-on-claude-desktop?ref=deletosh.com)general reference for adding MCP servers to Claude Desktop

### Tools Used

- [YouTrack](https://www.jetbrains.com/youtrack/?ref=deletosh.com)free tier available
- [Claude Desktop](https://code.claude.com/docs/en/desktop-quickstart?ref=deletosh.com)local desktop app (not the browser version)
- [Sublime Text](https://www.sublimetext.com/?ref=deletosh.com) or [VS Code](https://code.visualstudio.com/?ref=deletosh.com)for editing the JSON config file

---

## Questions I Get Asked

**Q: I already connected Claude Code to YouTrack in Lesson 6, do I really need to do this again?**

Yes, because they're completely separate connections. Claude Code connects via its own config inside WebStorm. Claude Desktop connects via its own JSON config file. They both talk to the same YouTrack instance, but from different tools. You need both set up if you want to use YouTrack from both places.

**Q: Can I use the same API token for both Claude Code and Claude Desktop?**

You can, but I prefer to create separate tokens so I can revoke one without affecting the other. It also makes it easier to see in YouTrack's Account Security which tool is doing what.

**Q: What's `mcp-remote`? Do I need to install it?**

`mcp-remote` is an npm package that handles the remote MCP connection. The config uses `npx` to run it, which means npm downloads and runs it automatically the first time, you don't need to install anything separately. As long as Node.js is installed on your machine, this works.

**Q: Why is the MCP key named `youtrack-prt` in the config?**

That's just the name I gave it. You can name it whatever you like, it's just an identifier inside the config file. I used `prt` as a shorthand for my project. The name doesn't affect how it functions.

**Q: How do I know I'm ready for the next lesson?**

You have YouTrack showing as "running" in Claude Desktop settings, and your smoke test (asking it to list or create an issue) worked. That's all you need.

---

## 💬 Stuck? Come Talk to Us

💡

If something's not clicking or you want to share what you've built, come find us in Discord.  
****Build What Ships community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community's active and I check in there too.

---

## Glossary

**MCP (Model Context Protocol):** The protocol that lets Claude connect to external tools and services. When we add an MCP server to Claude Desktop, we're giving Claude the ability to read and write to that tool directly from a chat window. *(first came up in Module 2, Lesson 4 with the Figma integration)*

**`claude_desktop_config.json`:** The configuration file that tells Claude Desktop which MCP servers to load when it starts. Lives in the Claude application data folder. You edit it directly with any text editor to add new integrations. *(first came up in this lesson)*

**API Token:** A secret key that authorises Claude to act on your behalf in YouTrack. It's tied to your account and grants whatever permissions your account has. Keep it private, anyone with your token can access your YouTrack. *(first came up in Module 3, Lesson 6 with the Claude Code + YouTrack setup)*

**`mcp-remote`:** An npm package that Claude Desktop uses to connect to remote MCP servers over the internet. Runs automatically via `npx`you don't install it yourself. *(first came up in this lesson)*

**Product Management template (YouTrack):** A project template in YouTrack that pre-configures fields like Estimate, Spent Time, and Due Date. Better suited for GTM and operational tasks than the default project template, which is more lightweight. *(first came up in this lesson)*
### Module 3, Lesson 7: Building Out the Project in YouTrack
URL: https://deletosh.com/courses/product-path/03-07-build-project-youtrack/
Last updated: 2026-07-16T15:33:44.000Z
## What is an Epic in YouTrack?

In YouTrack, an Epic is a large milestone that groups a set of related features under one heading, roughly a chapter for a phase of your product; it is its own issue type, and in this setup each phase of your implementation roadmap maps to one Epic.

Under each Epic sit User Stories with acceptance criteria, dependencies, and estimates. In this lesson you prompt Claude Code to read your specs, roadmap, and RICE priorities and populate a full Phase 1 board of Epics and Stories so development becomes a matter of clearing issues one by one.

**The short version: you take the spec, roadmap, and priorities you have produced and turn them into a structured YouTrack board with Claude, so development becomes a matter of clearing issues one by one. A well built board is what keeps the build focused. The full walkthrough is inside The Product Path.**

In this lesson, I'm taking everything we've built, the specs, the RICE prioritisation, the implementation roadmap, and using Claude Code to populate YouTrack with real, dev-ready issues. Epics, user stories, acceptance criteria, dependencies, the whole thing. By the end, we'll have a proper Agile board ready to hand to a developer (or to your future self in the build module).

ℹ️

The prompt I use in this lesson is shared in the Quick Reference section at the bottom. Don't write it from scratch, copy it, swap in your project ID and phase number, and you're good to go.

---

## Before We Start

Here's what I'd expect you to have under your belt before this lesson:

**From previous lessons:**

- Your implementation roadmap should be written and sitting in your `.project` folder ([Module 3, Lesson 5](https://deletosh.com/courses/the-product-path/03-05-implementation-roadmap/))
- Claude Code should be connected to YouTrack via MCP ([Module 3, Lesson 6](https://deletosh.com/courses/the-product-path/03-06-setup-claude-code-youtrack/))
- Your YouTrack project should be clean, if you have a demo project left over from testing, delete it before you start

**Tools / setup you'll need:**

- Claude Code running in your WebStorm terminal
- YouTrack with your real project open
- Your project ID handy (you'll need to drop it into the prompt)

**By the end of this lesson, you'll:**

- Understand how Epics and User Stories relate to each other in YouTrack
- Know how to prompt Claude Code to create properly structured issues from your roadmap
- Have a fully populated Phase 1 board in YouTrack, Epics, Stories, acceptance criteria, dependencies, and estimates

---

## What Is This Lesson About?

**Duration:** \~20 minutes video + \~30 minutes to run it on your own project  
**Skill Level:** Intermediate  
**What You'll Build:** A populated YouTrack Agile board for Phase 1 of your project, generated entirely by Claude Code from your existing specs and roadmap

This lesson is the payoff for all the planning work we did in Module 2 and the first half of Module 3\. All those documents, specs, and roadmap files, they weren't just nice to have. This is where they actually get used.

---

## Watch the Lesson

---

ℹ️

****How I'd suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section. After that, use the prompt in Quick Reference to run it on your own project.

---

## What We're Covering

Here's what I'm walking you through in this lesson and why it matters:

- **Cleaning up before you start**: why I always delete demo issues and start fresh before populating real data
- **The YouTrack issue prompt**: what it contains, why it's structured the way it is, and how to adapt it
- **How Claude Code asks clarifying questions**: and why that's actually a feature, not a bug
- **Epics vs. User Stories**: what they mean in YouTrack, and how this maps to real software engineering practice
- **What a "done" issue looks like**: acceptance criteria, technical deliverables, dependencies, estimates
- **Running Phase 2 and beyond**: same prompt, different phase number; it's that simple

---

## 1\. Start Clean *(\~0:00)*

The first thing I do before running the real prompt is clean house. If you still have any demo issues from testing the YouTrack MCP connection in the previous lesson, delete them now. Go into YouTrack, find the demo project if you made one, hit the ellipsis, go to settings, and delete it. You want to start with a clean project and zero issues.

Once your project is empty and you've confirmed it, no issues, just the project sitting there, we're ready.

---

## 2\. The Core Idea

### 2.1 Epics and User Stories

Before I walk you through the prompt, let me explain the structure we're building toward, because it's borrowed from how software teams have worked for years.

An **Epic** is a big milestone. Think of it as a chapter heading for a phase of your product. It groups a set of related features under one roof. In YouTrack, it's an issue type of its own, and in our setup, each phase of your implementation roadmap maps to one Epic.

A **User Story** is the specific thing you want to build within that milestone. Written in this format: *"As a \[persona\], I want to \[action\] so that \[benefit\]."* It answers: who wants this, what do they want to do, and why does it matter to them. Stories live as sub-issues (subtasks) under their parent Epic.

ℹ️

Think of it like a book outline. The Epic is the chapter. User Stories are the individual scenes inside that chapter. Each scene has its own beginning, middle, and end, but they all add up to the same chapter goal.

This structure isn't just for show. It means when you're in development, whether you're doing it yourself or handing it to someone else, you always know which story belongs to which milestone, what needs to be done first, and what "done" actually means for each piece.

### 2.2 Why This Connects to Everything We've Already Built

Everything we've done since Module 2 is feeding into this moment. The market research grounded the PRD. The PRD grounded the specs. The specs fed the RICE scoring. The RICE scores built the roadmap. And now the roadmap is becoming a live, actionable board.

When Claude Code reads the specs folder and the implementation roadmap, it's not guessing what to build, it's reading real documents we wrote. That's why the quality of what comes out of YouTrack is good. It's only as good as what went in.

---

## 3\. Let Me Show You How It Works *(\~1:30)*

### 3.1 Write Your Prompt in a Scratch File

Here's something I do every time I'm working with a long, complex prompt in Claude Code: I write it in a scratch file first.

In WebStorm, I hit `Ctrl+Shift+N` to open a new scratch file, just an empty text file sitting outside my project. I paste the prompt there, make my edits (swapping in the right project ID and phase number), then copy the whole thing and paste it into Claude Code.

This way, my prompt is saved. If Claude Code runs out of context and I need to restart, I don't have to re-type anything. I just grab it from the scratch file.

💡

Get into the habit of starting each new chunk of work in Claude Code with `clear` to free up context. You're not losing anything important, you want Claude Code focused on the current task, not dragging in everything it's ever seen in this session.

### 3.2 The Prompt

Here's the prompt I use. It's included in full in the **Quick Reference** section at the bottom, copy it from there.

What it does:

1. Tells Claude Code to read the specs folder and the implementation roadmap from your `.project` folder
2. Specifies your YouTrack project ID and which phase to build out
3. Defines the exact structure for Epics and User Stories, including the Markdown format for each issue
4. Tells it to use web search if it needs additional context to fill in the stories properly
5. Asks it to prioritise based on the feature parity matrix

One thing I added to the version I use: I told Claude Code to **ask me clarifying questions before it starts creating issues**. That extra line saves me a lot of cleanup. Instead of creating everything and having me fix it after, it checks in first.

### 3.3 Answering Claude Code's Clarifying Questions

When you paste the prompt and run it, Claude Code will ask you a set of questions before doing anything. This is normal, it's reading your project and verifying assumptions. Here's roughly what it asks and how I answered:

**Question 1: Issue types, do you have Epic and User Story types configured?**  
In my YouTrack setup, I have Epic. I don't have a dedicated "User Story" type, but I do have "Feature." So I told it: *use Feature for user stories.*

**Question 2: Assignee, should issues be assigned?**  
I said: *leave unassigned.* You can always assign manually later.

**Question 3: Custom fields, should it populate sprint, priority, or dev estimate?**  
YouTrack has an Estimation field built in. I added that to the project (under custom fields → use existing → Estimation) and told Claude Code: *use the Estimation field for dev estimates, ignore other fields.*

**Question 4: Subtask linking, how should user stories connect to epics?**  
I said: *link user stories as subtasks of their Epic.* This is how parent → child works in YouTrack, the Epic is the parent, the Stories are its children.

**Question 5: Phase scope, how should stories be grouped within the phase?**  
I told it to group closely related things together rather than strictly following sprint order. If several stories relate to the same flow (say, all the auth-related ones), they should be near each other. That makes implementation cleaner, you build related things in one push.

**Question 6: Tags, should it apply tags?**  
I said: *leave tags for now.* I prefer to apply tags manually as the project evolves. You don't need to get this perfect upfront.

Once I had my answers written out in the scratch file, I copied and pasted everything into Claude Code as one block and said "go."

### 3.4 Let It Run

From here, you can walk away. Claude Code will:

- Read your specs and roadmap
- Create an Epic for Phase 1
- Create all the User Stories as sub-issues under that Epic
- Add acceptance criteria, technical deliverables, success metrics, and dependencies to each story
- Set estimates where it can figure them out

When it comes back, it'll give you a summary. Don't just glance at it, read it. It'll tell you how many stories were created, what sprint estimates look like, and flag anything it had to make a call on.

⚠️

Claude Code will ask for permission to use tools as it works, hitting your YouTrack MCP, running searches, etc. I use the arrow key to select "Yes, don't ask again" for these because it'll be doing it repeatedly. If you approve them one at a time, it'll pause constantly and take forever.

---

## 4\. What a Done Issue Looks Like

Once it's finished, head into YouTrack and open one of the stories. Here's what you should see.

**The Epic:** Has a theme, a scope summary, success criteria for the whole milestone, and a target date. It lists all the child stories. It tells you how many developer days it should take in total.

**A User Story:** Follows this format:

```markdown
## User Story
As a [persona], I want to [action] so that [benefit].

## Acceptance Criteria
- [ ] [Testable criterion]
- [ ] [Testable criterion]

## Technical Deliverables
- [Specific implementation item]
- [Specific implementation item]

## Success Metrics
- [Measurable outcome]

## Dependencies
- Blocked by: [PROJ-XXX]
- Blocks: [PROJ-YYY]

## Context
[Additional notes — relevant spec links, edge cases, background]

```

That's what a properly constructed story looks like. Not just a title. Not just "as a user, I want to log in." A complete brief that a developer, human or AI, can pick up and work from without asking you a dozen follow-up questions.

ℹ️

Notice the stories reference your internal spec files in the Context section. That's intentional. Whoever is building this, you or someone else, can trace every story back to the original spec. Nothing is hanging in the air.

The right-hand panel in YouTrack shows the metadata: issue type (Feature/Epic), priority, assignee, and the Estimation field. Stories also show their dependencies, if one story is blocked by another, that link is live. Click it and it takes you directly to the blocking issue.

---

## 5\. Running Phases 2 and 3

Once Phase 1 is in there, doing the rest is simple. I don't clear Claude Code's context between phases, I want it to remember what it just did for Phase 1, so the stories are consistent.

I add to the conversation: *"Let's now work on scoping out Phase 2."* Then I paste the same prompt with `Phase 1`replaced by `Phase 2`. That's it.

If you're running low on context (Claude Code will usually tell you), you can clear it and re-run the full original prompt with the new phase number. The prompt has everything it needs to reconstruct the context from your files.

I do the remaining phases off camera in the video, it's the same process, just repeated. You don't need to watch me do it twice.

💡

Nothing here is permanent. If Claude Code creates something that doesn't look right, you can edit issues directly in YouTrack, or come back to Claude Code and say "update issue \[ID\] to reflect X." This isn't a one-shot process, it's a living board.

---

## 6\. A Note on What This Is Really For

I want to be honest about the scale of what this produces. When you open the Epic and see thirty-something stories with multi-day estimates, it can feel overwhelming. This takes real work to build. It's not vibing along, if you want software that lasts, it's going to take time.

But the point isn't to scare you. The point is that now you *know*. You have a realistic picture of the project before you write a single line of code. That's infinitely better than finding out six weeks in that you've built the wrong thing in the wrong order with no way to track what's done and what isn't.

And if you're not doing the build yourself, if you're passing this to a developer or an agency, hand them this YouTrack board. Every story is traceable back to a spec. Every spec is traceable back to research. That's the whole pipeline.

---

## 7\. You Should Be Able to Build This Now

Here's what you can put together with what we just covered:

- A fully populated YouTrack Agile board for any phase of your project, generated from your specs and roadmap
- A repeatable process you can run for each phase as you go

### Check Yourself

- I've deleted any demo issues and started with a clean YouTrack project
- I've run the prompt for Phase 1 and have an Epic with User Stories in YouTrack
- I can open a story and see acceptance criteria, technical deliverables, and dependencies
- I understand the difference between an Epic and a User Story in this context

✅

If you're ticking those boxes, you're ready for the next lesson. The hard planning work is done. The next module is where we actually build it.

### If Something's Not Working

⚠️

****Claude Code created stories but they're not showing as subtasks of the Epic**  
****What's happening:** The subtask link didn't get created, so stories are floating as standalone issues.  
****How to fix it:** Open each story in YouTrack and manually set the parent to the Epic. Or re-run the prompt and explicitly add: "make sure all user stories are linked as subtasks of their parent Epic via the subtask relationship."

⚠️

****Claude Code stops and asks me to approve every tool call**  
****What's happening:** Default behaviour, it asks before using each MCP tool.  
****How to fix it:** Use your arrow key to select "Yes, don't ask again" the first time it prompts. This applies for the rest of the session.

⚠️

****YouTrack issue types don't match what the prompt expects**  
****What's happening:** Your YouTrack project might not have "Epic" or "User Story" types configured.  
****How to fix it:** When Claude Code asks its clarifying questions, tell it which types you actually have. In my setup: Epic = Epic, User Story = Feature. Just tell it what to use and it'll adapt.

---

## The Short Version

Here's what I want you to walk away with:

- **Epics = milestones.** One per phase. They group everything in that phase together and give it a target date and success criteria.
- **User Stories = the individual things to build.** Written as "As a \[persona\], I want to \[action\] so that \[benefit\]." They live as subtasks under their Epic.
- **The prompt does the heavy lifting.** You write the specs and roadmap once. Claude Code translates them into YouTrack issues. You just have to answer a few setup questions first.
- **What you can do now:** Start the build module. Your board is ready.

---

## Quick Reference

### The Prompt

This is the full prompt used in this lesson. Copy it, replace `[YOUR-PROJECT-ID]` with your actual YouTrack project ID, and replace `Phase [X]` with the phase you're building out:

```
Review the specs in the specs folder and the implementation roadmap.
Using the YouTrack tool (Project ID: "[YOUR-PROJECT-ID]"), create issues for Phase [X].
Follow this structure:

## Epics (one per phase)
- Type: Epic
- Summary: "Phase X: [Phase Name]"
- Description: Include theme, success criteria, and target completion date

## User Stories (subtasks of Epic)
- Type: User Story
- Summary: Clear, action-oriented title (no prefixes like "US-001")
- Description format:

## User Story
As a [persona], I want to [action] so that [benefit].

## Acceptance Criteria
- [ ] [Testable criterion 1]
- [ ] [Testable criterion 2]
- [ ] [Testable criterion 3]

## Technical Deliverables
- [Specific implementation item 1]
- [Specific implementation item 2]

## Success Metrics
- [Measurable outcome]

## Dependencies (Link this inside YouTrack as well)
- Blocked by: [PROJ-XXX] (link to YouTrack issue)
- Blocks: [PROJ-YYY]

## Context
[Additional information a developer needs - relevant spec links, edge cases]

Additionally, when needed, please pull additional context/latest with the web search tool.

Before creating any issues, ask me clarifying questions. Prioritise issues based on the feature parity matrix.

```

### Moving to the Next Phase

Once Phase 1 is done, continue in the same Claude Code session (don't clear unless you're out of context) and say:

```
Let's now work on scoping out Phase 2.

```

Then paste the same prompt with `Phase [X]` updated to `Phase 2`. Repeat for each phase.

### YouTrack Custom Fields to Add

If Claude Code asks about estimation fields and you don't see one, here's how to add it:

1. In YouTrack, go to your project → Settings → Fields
2. Click **Add field to project**
3. Select **Use existing** → find **Estimation**
4. Save

Now Claude Code can populate dev estimates on each story.

---

## Resources

### Links & Docs

- [YouTrack Agile Boards documentation](https://www.jetbrains.com/help/youtrack/server/agile-boards.html?ref=deletosh.com)useful if you want to customise your board view after populating it
- [YouTrack Issue Types](https://www.jetbrains.com/help/youtrack/server/issue-types.html?ref=deletosh.com)reference for understanding Epic, Feature, and other types

### Tools Used

- [YouTrack](https://www.jetbrains.com/youtrack/?ref=deletosh.com)free tier available
- Claude Code, installed in Module 3, Lesson 3
- WebStorm (or VS Code), terminal host for Claude Code

---

## Questions I Get Asked

**Q: Do I have to do all phases at once?**

No, and honestly I wouldn't. Do Phase 1, see how the board looks, and adjust your prompt or your answers to the clarifying questions if needed. Once you're happy with how Phase 1 turned out, do Phase 2\. The prompt is the same either way.

**Q: What if my YouTrack doesn't have Epic as an issue type?**

When Claude Code asks its clarifying questions, just tell it what types you have. If you only have "Feature" and "Task," tell it to use Feature for epics and Task for stories. It'll adapt. The naming matters less than the parent → child relationship.

**Q: Can I edit the stories after they're created?**

Absolutely. YouTrack is just a database at this point. You can edit issue titles, update acceptance criteria, change estimates, add assignees, all of it. Claude Code can also go back and edit issues if you ask it to. Nothing here is carved in stone.

**Q: How do I know I'm ready for the next lesson?**

If you have an Epic in YouTrack for Phase 1 with User Stories underneath it, and you can open one of those stories and see acceptance criteria and dependencies, you're ready.

---

## 💬 Stuck? Come Talk to Us

💡

If something's not clicking or you want to share what you've built, come find us in Discord.  
****Build What Ships community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community's active and I check in there too.

---

## Glossary

**Epic:** A high-level milestone in YouTrack that groups related user stories together. One Epic per phase of the implementation roadmap. Tracks the theme, scope, success criteria, and target date for that milestone. *(first came up in Module 3, Lesson 7)*

**User Story:** A description of a feature from the user's perspective, written as "As a \[persona\], I want to \[action\] so that \[benefit\]." Lives as a subtask under its parent Epic. The smallest unit of work that has a clear definition of done. *(first came up in Module 3, Lesson 7)*

**Acceptance Criteria:** The specific, testable conditions that define when a user story is complete. Written as checkboxes so that both a human and an AI can verify against them during development. *(first came up in Module 3, Lesson 7)*

**Subtask:** In YouTrack, the parent → child relationship between an Epic and its User Stories. A story is a subtask of its Epic. This is how you navigate between the big milestone and the individual pieces of work. *(first came up in Module 3, Lesson 7)*

**Scratch file:** A temporary empty text file you open in your IDE (Ctrl+Shift+N in WebStorm) for writing and saving prompts before pasting them into Claude Code. Not part of your project, just a working notepad. *(first came up in Module 3, Lesson 7)*
### Module 3, Lesson 6: Set Up Claude Code + YouTrack
URL: https://deletosh.com/courses/product-path/03-06-setup-claude-code-youtrack/
Last updated: 2026-07-16T15:33:43.000Z
## How do you connect Claude Code to YouTrack?

You connect Claude Code to YouTrack by creating a YouTrack API token and adding a .mcp.json config file in your project root that points Claude Code at YouTrack over MCP, then starting Claude Code with the flag that loads only that project's MCP servers.

Once connected, Claude Code can read and write issues directly, so your roadmap becomes a live agile board it can update. In this lesson you set up the YouTrack project and custom fields, wire up the connection, and verify it by having Claude Code create a test issue.

**The short version: you wire Claude Code into YouTrack so your roadmap becomes a live agile board that Claude can read and update directly, turning specs into a dev ready project. This connection is what makes the build issue by issue instead of ad hoc. The full setup is inside The Product Path.**

In this lesson, I'm picking up from the implementation roadmap we wrote in [Module 3, Lesson 5](https://deletosh.com/courses/the-product-path/03-05-implementation-roadmap/) and connecting everything to our project tracking system, YouTrack, so that Claude Code can read and write issues directly.

ℹ️

The command used to start Claude Code with a project-specific MCP config has a specific syntax, I'll give you the exact command in this lesson. Don't type it from memory; copy it from Section 3.

---

## Before We Start

Here's what I'd expect you to have under your belt before this lesson:

**From previous lessons:**

- You should have your prioritisation document and implementation roadmap already written (Module 3, [Lessons 4](https://deletosh.com/courses/the-product-path/03-04-design-rice/) and [Lesson 5](https://deletosh.com/courses/the-product-path/03-05-implementation-roadmap/))
- You should have Claude Code installed and be able to run it from your terminal ([Module 3, Lesson 3](https://deletosh.com/courses/the-product-path/03-03-install-claude-code/))
- Your project should be open in WebStorm with your specs folder already in place

**Tools / setup you'll need:**

- YouTrack account, free tier is fine; sign up at [jetbrains.com/youtrack](https://www.jetbrains.com/youtrack/?ref=deletosh.com) if you haven't already
- Claude Code installed and working in your terminal
- WebStorm (or VS Code) open with your project folder
- Your `.mcp.json` file, we'll create this together in the lesson

**By the end of this lesson, you'll:**

- Have a YouTrack project set up and configured with the right custom fields
- Have a `.mcp.json` config file in your project root that connects YouTrack to Claude Code
- Know how to start Claude Code so it loads only the MCP servers for that specific project
- Have verified the connection by having Claude Code create a test issue in YouTrack

---

## What Is This Lesson About?

**Duration:** \~14 minutes video + \~20 minutes setup  
**Skill Level:** Intermediate  
**What You'll Build:** A live, bidirectional connection between Claude Code and YouTrack, your AI coding agent can now read from and write to your project tracker.

This lesson is about plumbing. It's not glamorous, but once this connection is solid, everything in the next phase becomes dramatically smoother. You're not just setting up a tool, you're wiring up the system that will let Claude Code act as a real collaborator on your project, not just a standalone chat assistant.

---

## Watch the Lesson

---

ℹ️

****How I'd suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section. There are a few places where you'll need to pause and grab values from YouTrack (like your token and project short code), so having this guide open alongside the video makes that a lot easier.

---

## What We're Covering

Here's what I'm walking you through in this lesson and why it matters:

- **Setting up YouTrack**: creating your project, adding the right custom fields, and getting your Agile board ready
- **Generating a YouTrack API token**: the key that lets Claude Code talk to your tracker
- **Creating the `.mcp.json` config**: how I wire up MCP servers on a per-project basis (and why I do it this way instead of globally)
- **The Claude Code startup command**: the specific flag you need to load only the MCP servers for your project
- **Verifying the connection**: having Claude Code create a real issue in YouTrack as a live test

---

## 1\. Let's Set the Scene *(\~0:00)*

At this point you should have your specs and implementation roadmap written. If you open WebStorm and look at your project, you should see your specs folder sitting there with the work we did in Module 3, Lessons 2 through 5.

Now we're going into the project planning phase. The reason we plan in a tracker, rather than just keeping everything in files, is so we know where we are at any given point. When Claude Code is doing the actual coding later, we're not just vibing and hoping for the best. We've done the hard thinking upfront, and now we want somewhere to track the progress of all that work.

This is also useful if you're collaborating with other people, or if you're scoping this out to hand off to someone else. Either way, you want it well structured, and that's what YouTrack gives us.

---

## 2\. Setting Up YouTrack *(\~0:53)*

### 2.1 Create Your Account

Head to [jetbrains.com/youtrack](https://www.jetbrains.com/youtrack/?ref=deletosh.com) and sign up. It's straightforward. Once you're in, you'll land in a dashboard that's mostly empty for now.

### 2.2 Create a Kanban Project

Don't do anything on the dashboard just yet. The first thing you want to do is create a project:

1. Go to **Projects → New Project**
2. Choose **Kanban** as the project type
3. Give your project a name, I'm calling mine *Notero Development* (yours will be whatever your app is called)
4. Give it a **short code**: this is the project ID prefix for all your issues (mine is `NERT`)

⚠️

****Note the short code down.** You'll need it later when you tell Claude Code which project to write issues into. Don't skip this step.

### 2.3 Add the Type Custom Field

Once your project is created and you're inside it, go to **Custom Fields** and check what's already there. You should see Priority and Assignee by default. I also add **Type**:

1. Click **Add fields to project → Use existing**
2. Search for **Type** and add it
3. By default it comes with: Bug, Statistics, Usability, Performance, that's fine, leave it

This makes it easier for both you and Claude to categorise work properly later. You don't need to touch anything else in Custom Fields for now.

### 2.4 Check the Agile Board

Go to **Agile Boards** and take a look. It'll show the default columns (Open, In Progress, Done, etc.). Leave it as is for now, I'll cover board organisation in the next phase. For now you just need to confirm the project is set up and the board is there.

---

## 3\. Connecting YouTrack to Claude Code *(\~4:10)*

This is the core of the lesson. Two things need to happen: you need a YouTrack API token, and you need a `.mcp.json`file in your project root that tells Claude Code how to connect.

### 3.1 Generate an API Token in YouTrack

1. In YouTrack, click your **profile name** (top right, probably says "admin" by default)
2. Go to **Profile → Account Security → Tokens**
3. Click **New Token** and give it a name, I call mine `MCP`
4. Copy the token and save it somewhere safe immediately, you won't see it again

⚠️

Copy the token as soon as it's generated. YouTrack won't show it to you again after you close that window. I paste mine temporarily into a scratch file in WebStorm just to have it on hand while I set things up.

### 3.2 Create the `.mcp.json` File

In WebStorm, click on your project folder, choose **New File**, and name it `.mcp.json`. This file lives at the top level of your project, not inside any subfolder.

Here's the config you want:

```json
{
  "mcpServers": {
    "youtrack": {
      "type": "http",
      "url": "https://<username>.youtrack.cloud/mcp",
      "headers": {
        "Authorization": "Bearer <token>"
      }
    }
  }
}

```

Replace two things:

- `<username>` → your YouTrack instance name (the subdomain of your YouTrack URL, mine is `deletosh`)
- `<token>` → the token you just generated

So a real example looks like:

```json
{
  "mcpServers": {
    "youtrack": {
      "type": "http",
      "url": "https://deletosh.youtrack.cloud/mcp",
      "headers": {
        "Authorization": "Bearer perm:abc123yourtokenhere"
      }
    }
  }
}

```

Save the file.

ℹ️

****Why HTTP, not the official docs approach?** If you search online for how to connect YouTrack to MCP, the official documentation shows a different method. I've found that approach can get messy when you're working on multiple projects, especially when you also have other MCP servers (like Figma) installed globally on Claude Desktop. Using HTTP in a project-specific file keeps things clean and portable.

### 3.3 Start Claude Code with Project-Specific MCP

This is the key part, and the reason I keep MCP config per-project rather than globally.

When you just type `claude` in your terminal, Claude Code starts with whatever MCP servers you've set up globally. The problem is, if you've got Figma, Obsidian, and half a dozen other MCPs installed globally from Claude Desktop, Claude Code gets confused about which tools to use.

My approach: I start Claude Code and explicitly tell it which MCP config to load. Here's the command:

```bash
claude --strict-mcp-config --mcp-config .mcp.json

```

What this does:

- `--strict-mcp-config`tells Claude Code to *only* load the MCP servers defined in the config file I specify. Nothing else.
- `--mcp-config .mcp.json`points to the `.mcp.json` file in the current project directory

From this point on, whenever you start a Claude Code session on this project, use this command instead of just `claude`.

💡

I work on multiple projects at once. By putting the MCP config inside each project folder and using `--strict-mcp-config`, each project only loads the tools it actually needs. It keeps Claude focused and avoids weird cross-project tool conflicts.

---

## 4\. Verifying the Connection *(\~10:19)*

### 4.1 Check MCP Servers Are Loaded

After you run the startup command, Claude Code opens in your terminal. Type:

```
/mcp

```

This shows you all the MCP servers that are currently loaded. You want to see **YouTrack** listed with status **connected**. If it's not there, or it shows an error, stop here and retrace the steps above before continuing.

### 4.2 Test with a Sample Issue

Once you can see YouTrack connected, do a quick sanity test. Type something like:

```
Using the YouTrack tool, create a sample issue in my project NERT

```

(Replace `NERT` with your actual project short code.)

Claude Code will ask you to confirm before it runs the tool, that's by design. Say yes. If everything is wired up correctly, you'll see it confirm the issue was created. Then flip over to YouTrack in your browser, refresh the project, and the issue should be sitting right there.

✅

If you can see that test issue in YouTrack, you're done. The connection is live. Claude Code can now read from and write to your project tracker.

---

## 5\. Watch Out For These

⚠️

****YouTrack not showing as connected in /mcp**  
What's happening: The URL or token in your `.mcp.json` is wrong, or the file isn't saved properly.  
How to fix it: Double-check the URL (make sure it's your actual YouTrack subdomain) and that the token has no extra spaces. Also confirm the file is at the root of your project folder, not inside a subfolder.

⚠️

****Claude Code creating issues in the wrong project**  
What's happening: You didn't specify the project short code when you asked Claude to create an issue.  
How to fix it: Always include the project short code in your prompt, "create an issue in project NERT". That's why we noted it down during setup.

⚠️

****Starting Claude Code with just** **`claude`** **and wondering why YouTrack isn't there**  
What's happening: You're not loading the project MCP config.  
How to fix it: Always use the full startup command: `claude --strict-mcp-config --mcp-config .mcp.json`

---

## 6\. Practice

### Exercise 1: Full Setup from Scratch

**What to do:** Close this guide and redo the entire setup flow from memory, YouTrack project, custom fields, token, `.mcp.json`, startup command. Use the guide only to check yourself at the end.

**How you'll know it's working:** You run `/mcp` inside Claude Code and see YouTrack as connected.

### Exercise 2: Create and Delete Test Issues

**What to do:** Ask Claude Code to create three test issues in your YouTrack project with different types (Bug, Task, Feature). Then go into YouTrack manually and delete them.

**What this is practising:** Getting comfortable with the back-and-forth between Claude Code and YouTrack, you'll be doing a lot of this in the build phase.

---

## 7\. You Should Be Able to Build This Now

With this lesson done, you can:

- Set up a YouTrack project for any new app you're building
- Wire Claude Code to that project via a project-specific MCP config
- Verify the connection is live before you start any real work

### Check Yourself

- I have a YouTrack project created with a short code I know
- I have a `.mcp.json` in my project root with the correct URL and token
- I can start Claude Code with `--strict-mcp-config --mcp-config .mcp.json`
- Running `/mcp` shows YouTrack as connected
- I've created a test issue via Claude Code and confirmed it appeared in YouTrack

✅

If those boxes are ticked, you're ready for the next lesson, where we take all the specs and roadmap we've built and actually populate YouTrack with real project issues.

### If Something's Not Working

⚠️

****Token not working / 401 Unauthorised**  
****What's happening:** The token was copied incorrectly or has expired.  
****How to fix it:** Go back to YouTrack → Profile → Account Security → Tokens, revoke the old one, generate a new one, and update your `.mcp.json`.

---

## The Short Version

Here's what I want you to walk away with:

- **YouTrack is your project command centre**: it's where all your issues live and where you'll track progress through the build phase.
- **The `.mcp.json` file is the bridge**: it tells Claude Code how to talk to YouTrack, and keeping it project-specific avoids a lot of headaches.
- **Always start Claude Code with the full command**`claude --strict-mcp-config --mcp-config .mcp.json`so it only loads the tools your project needs.
- **Verify before you move forward**: run `/mcp`, confirm YouTrack shows connected, create a test issue. Don't skip this.

---

## Quick Reference

### Claude Code Startup Command

```bash
claude --strict-mcp-config --mcp-config .mcp.json

```

### `.mcp.json` Template

```json
{
  "mcpServers": {
    "youtrack": {
      "type": "http",
      "url": "https://<your-username>.youtrack.cloud/mcp",
      "headers": {
        "Authorization": "Bearer <your-token>"
      }
    }
  }
}

```

### Claude Code MCP Commands

```
/mcp          — lists all loaded MCP servers and their connection status

```

### YouTrack Token Location

Profile → Account Security → Tokens → New Token

---

## Resources

### Links & Docs

- [YouTrack](https://www.jetbrains.com/youtrack/?ref=deletosh.com)project tracking tool used in this course
- [YouTrack MCP documentation](https://www.jetbrains.com/help/youtrack/server/model-context-protocol-server.html?ref=deletosh.com)official docs (I use a different approach to what's shown here, but worth knowing it exists)
- [Claude Code documentation](https://docs.anthropic.com/en/docs/claude-code?ref=deletosh.com)reference for Claude Code commands and flags

### Tools Used

- [YouTrack](https://www.jetbrains.com/youtrack/?ref=deletosh.com)free tier, sign up at jetbrains.com
- [Claude Code](https://docs.anthropic.com/en/docs/claude-code?ref=deletosh.com)the agentic coding tool we're running in the WebStorm terminal

---

## Questions I Get Asked

**Q: Can I use a different project tracker, Jira, Linear, Asana?**

You can, as long as it supports MCP. That's the only requirement. YouTrack has excellent MCP support and it integrates well with WebStorm, which is why I use it. But if your team is already on Jira or Linear and those tools have MCP support, the same principles apply, you'd just swap out the config in your `.mcp.json`.

**Q: Do I need to keep the `.mcp.json` out of version control?**

Good question. It contains your API token, so yes, add `.mcp.json` to your `.gitignore` if you're pushing this project to GitHub. You don't want your token in a public repo.

**Q: Why use `--strict-mcp-config` instead of just `--mcp-config`?**

The `--strict-mcp-config` flag tells Claude Code to load *only* the servers in that file and nothing else. Without it, Claude Code might still load globally installed MCP servers on top of your config file. The strict flag keeps it clean, only the tools this project needs.

**Q: How do I know I'm ready for the next lesson?**

If you've done the exercises and can tick the checklist above, you're good. Don't overthink it.

---

## 💬 Stuck? Come Talk to Us

💡

If something's not clicking or you want to share what you've built, come find us in Discord.  
****The Product Path community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community's active and I check in there too.

---

## Glossary

**MCP (Model Context Protocol):** The protocol that lets AI agents like Claude communicate with external tools and services. We've been using it throughout the course, Figma, Obsidian, JetBrains, and now YouTrack all connect to Claude via MCP. *(first came up in* [*Module 2, Lesson 3*](https://deletosh.com/courses/the-product-path/02-03-generate-technical-document/) *\- Generating the Technical Document)*

**`.mcp.json`:** A project-specific configuration file that defines which MCP servers Claude Code should connect to when running in that project. Keeping this per-project (rather than global) avoids tool conflicts across multiple projects. *(introduced in this lesson)*

**`--strict-mcp-config`:** A Claude Code startup flag that restricts it to only loading the MCP servers defined in the specified config file, nothing else. *(introduced in this lesson)*

**YouTrack short code:** The prefix used for all issue IDs in your YouTrack project (e.g. `NERT-1`, `NERT-2`). Set when creating the project and needed when directing Claude Code to a specific project. *(introduced in this lesson)*

**API token:** A generated credential that allows external tools (like Claude Code) to authenticate with a service (like YouTrack) on your behalf. Treat it like a password, don't commit it to version control. *(introduced in this lesson)*
### Module 3, Lesson 5: Writing the Implementation Roadmap
URL: https://deletosh.com/courses/product-path/03-05-implementation-roadmap/
Last updated: 2026-07-16T15:33:41.000Z
## What is an implementation roadmap?

An implementation roadmap is a phased, sprint-based delivery plan that sequences your prioritised features into a build order that respects dependencies and capacity, with each phase ending in something you can actually ship to users.

It answers when and in what order to build, which a RICE priority list on its own does not. In this lesson you prompt Claude to turn your Feature Priority Matrix into a roadmap with phases, sprints, a risk register, and release checkpoints saved to your project.

**The short version: you take the Feature Priority Matrix and prompt Claude to sequence it into a roadmap that respects dependencies, so the build has a clear order instead of a pile of tasks. The roadmap is the bridge between planning and execution. The full process is inside The Product Path.**

In this lesson, I'm taking the Feature Priority Matrix we generated in Lesson 4 and turning it into something you can actually execute against, a phased implementation roadmap, broken down into sprints, with a risk register and release checkpoints built in.

ℹ️

No corrections or updates to flag from previous lessons. Carry everything forward.

---

## Before We Start

Here's what I'd expect you to have in place before this lesson:

**From previous lessons:**

- Your `.project/feature-priority-matrix.md` exists, generated in Module 3, Lesson 4
- Your `/specs` folder is populated with feature spec files, from Module 3, Lesson 2
- Claude Code is installed and running in your WebStorm terminal

**Tools / setup you'll need:**

- WebStorm open with your project loaded
- Claude Code running in the terminal (`claude` command works)
- Your `.project/feature-priority-matrix.md` file ready, this is the primary input for this lesson

**By the end of this lesson, you'll:**

- Understand what an implementation roadmap is and why it needs to come from the RICE matrix, not your gut
- Know how to write the prompt that turns the priority matrix into a sprint-by-sprint delivery plan
- Have a `.project/implementation-roadmap.md` saved in your project, a real, structured roadmap with phases, sprints, a risk register, and release checkpoints
- Understand how the design-dev pipeline fits into sprint planning (it's not just developers)

---

## What Is This Lesson About?

**Duration:** \~10 minutes video + \~20 minutes practice  
**Skill Level:** Intermediate  
**What You'll Build:** An Implementation Roadmap document, phased delivery plan, sprint breakdown, risk register, and release checkpoints saved in your project.

The last lesson gave you a ranked list of what to build. This lesson answers the follow-up question: *when*, and in what order. It sounds like it should be simple, just take the RICE scores and line them up chronologically. But there's more to it than that. Dependencies matter. Design has to stay ahead of development. Capacity is real. And you need to know, at the end of every phase, what you can actually ship to users.

That's what this lesson covers.

---

## Watch the Lesson

---

ℹ️

****How I'd suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section, pausing the video at the timestamps I've noted. After that, this guide is your reference, you shouldn't need to rewatch to look something up.

---

## What We're Covering

Here's what I'm walking you through in this lesson:

- **Why prioritisation alone isn't a plan**: knowing what's highest priority doesn't tell you when to build it or whether you have the capacity to build it
- **The design-dev pipeline**: design has to stay ahead of development. If you're not planning for this, you'll get blocked
- **How to write the roadmap prompt**: the specific structure I use to turn the RICE matrix into a phased, sprint-based delivery plan
- **What "shippable" means at the end of each phase**: not just "code complete" but something a real user can actually get value from
- **The risk register**: identifying risks before they bite you, not after

---

## 1\. Let's Set the Scene *(\~0:00)*

We're at the point in the process where we've defined *what* to build, the RICE matrix took care of that. Now we need to define *when*.

And this is where I've seen a lot of people, myself included, early on, skip a step. They look at their priority list and just start building the top item. Which sounds logical. But without a roadmap, you end up in a situation where you're building features in isolation, design isn't ready, things block each other, and you're three months in with nothing you can actually ship.

The implementation roadmap is the answer to that. It's not a Gantt chart. It's not a waterfall plan. It's a phased delivery structure, phases that each end with something shippable, broken down into two-week sprints, with the design pipeline explicitly planned in.

You're going to run one prompt in Claude Code and get a properly structured roadmap document out of it. That document lives in your project, right next to your specs and your priority matrix.

---

## 2\. The Core Idea

### 2.1 Why "Just Build the Top RICE Features" Isn't Enough

Let me explain the gap that this roadmap fills.

Your RICE matrix gives you a ranked list. Feature A scores highest, followed by B, C, D, and so on. But here's the problem: some features depend on others. You can't build Feature C until Feature A exists. You can't build Feature E until the auth system is done. The RICE score doesn't account for that, it's a priority rank, not a build order.

On top of that, you have real capacity constraints. You've got a fixed number of developers, a fixed number of hours per sprint, and design work that needs to happen *before* development, not at the same time.

The roadmap takes the RICE output and applies these real-world constraints to produce something you can actually execute.

### 2.2 The Design-Dev Pipeline

This is the one thing most solo founders and small teams overlook: **design has to be done before a story enters a dev sprint.**

If you're designing and developing at the same time, you're constantly blocking yourself. The developer finishes building something, then the design changes, and you have to rebuild it. That's wasted effort.

The way I structure it is simple: design runs at least one sprint ahead of development. If a story is going into Sprint 3 for development, the design deliverables for that story need to be ready by the end of Sprint 2\. The roadmap prompt I use makes this explicit, it tracks design status per sprint so you always know whether you're at risk of a design-dev collision.

ℹ️

On the course project, design is handled by a freelancer, which is exactly the scenario most builders are in. The roadmap tracks design as a separate workstream that feeds into dev, rather than treating it as something that happens alongside dev. If you're doing your own design, the same principle applies, don't design and build the same thing at the same time.

### 2.3 Release Checkpoints: What Can You Actually Ship?

At the end of every phase, I ask one question: what can we ship to users right now?

Not "what is technically complete", but what delivers real value that a real user can benefit from. If you can't answer that question at the end of a phase, the phase isn't structured right.

This matters because it forces you to think in terms of user value, not engineering milestones. A half-built feature that you can't ship is a cost, not progress. The release checkpoint structure makes sure every phase ends with something that can go in front of users.

### 2.4 How This Builds on Module 3, Lesson 4

The input to this lesson is the `.project/feature-priority-matrix.md` file we generated in Module 3, Lesson 4\. The roadmap prompt reads that file directly, so Claude is working from your actual scored and ranked features, not guessing. If you don't have that file yet, go back and do Lesson 4 first.

---

## 3\. Let Me Show You How It Works *(\~1:30)*

### 3.1 The Prompt

Here's the prompt I use to generate the implementation roadmap. You have access to this, copy it and run it in Claude Code:

```text
Based on the .project/feature-priority-matrix.md, create an Implementation Order Roadmap.

Write to: .project/implementation-roadmap.md

Structure as follows:

## Roadmap Overview
- Total phases: [X]
- Sprint cadence: 2 weeks
- Dev team capacity: [X] developers × [Y] days per sprint = [Z] person-days
- Design: Freelance (tracked separately)

## Design-Dev Pipeline
Design must be complete before stories enter a sprint. Plan for:
- Design lead time: [X weeks ahead of dev sprint]
- Design deliverables: Figma files with approved UI/UX

## Phase 1: [Phase Name] (Sprints 1-2)
**Theme:** [What value does this phase deliver?]
**Success Criteria:** [How do we know this phase is done?]
**Design Status:** [Complete / In Progress / Not Started]

### Sprint 1 (Week 1-2)
| Story | Priority | Dev Estimate | Dependencies | Design Ready |
|-------|----------|--------------|--------------|--------------|

### Sprint 2 (Week 3-4)
[Same format]

## Phase 2: [Phase Name] (Sprints 3-4)
[Continue pattern]

## Risk Register
| Risk | Likelihood | Impact | Mitigation |
|------|------------|--------|------------|

## Release Checkpoints
After each phase, what is shippable to users?

Before you start, where relevant, do additional web search for context with the web search tool and ask me additional questions for clarity with the ask user question tool.

```

⚠️

****Notice the last two lines of the prompt.** These are instructions telling Claude to ask you questions before it starts writing. Answer those questions carefully, they're usually about your team size, sprint cadence, or design constraints. The more specific your answers, the more accurate the roadmap.

### 3.2 Running It in Claude Code

Open your terminal in WebStorm (`Cmd + E` → Terminal), run `claude` if it's not already running, and paste the prompt.

Before Claude writes anything, it will likely ask you a few clarifying questions, team size, number of developers, design availability, target timeline. This is the prompt's `ask user question tool` instruction doing its job. Answer these specifically. Don't be vague.

When Claude asks if it can make changes to your files, **allow edits for the session**. Same as Lesson 4, you want it to write the file without asking permission before every change.

When it's done, navigate to `.project/implementation-roadmap.md` in your project.

### 3.3 What Claude Does With This

When Claude runs this prompt, it's doing several things simultaneously:

1. Reading the `.project/feature-priority-matrix.md`it knows your features, their scores, and their dependencies from the previous lesson
2. Applying your capacity constraints (developer count × days per sprint) to figure out what actually fits in each sprint
3. Respecting the dependency map from the RICE matrix, it won't schedule Feature C before Feature A if A is a dependency
4. Keeping the design pipeline a sprint ahead of dev
5. Ending each phase at a natural "shippable" point
6. Building a risk register for the things most likely to cause problems

The output is a structured Markdown file you can read, share, and update as the project evolves.

---

## 4\. Reading the Output

Here's what to look at when you open the roadmap:

**Roadmap Overview**: check that the capacity numbers are right. If Claude guessed your team size or sprint length, correct it and re-run. Everything downstream depends on these numbers.

**Design-Dev Pipeline**: check the design lead times. Is design actually scheduled far enough ahead of the dev sprints it feeds? If a story is going into Sprint 3 dev but design is also scheduled for Sprint 3, that's a problem. Design needs to be Sprint 2 at the latest.

**Phase themes**: each phase should tell a clear story about what a user can do by the end of it. If a phase theme sounds like an engineering task ("Set up the database layer") rather than user value ("Users can sign up and log in"), that phase probably needs to be reframed.

**Sprint tables**: look at the Dependencies column. If anything in Sprint 1 has a dependency that isn't already built, that needs to move or the dependency needs to be in Sprint 1 too. Don't let blocked stories sneak into early sprints.

**Risk Register**: read this carefully. Claude will flag the most likely risks based on your features and dependencies. Most of these will be things you already knew, but seeing them written down with likelihood and impact scores forces you to think about mitigation before it's a crisis.

**Release Checkpoints**: this is the most important section. For each phase, ask yourself: would I genuinely be comfortable putting this in front of a user? If the answer is no, the phase needs adjusting.

🔥

The release checkpoint question is a forcing function. If you can't ship something real to users at the end of Phase 1, you've probably front-loaded too much infrastructure. Infrastructure has to serve user value, if it's not enabling something a user can touch by the end of the first phase, reconsider the phasing.

---

## 5\. Watch Out For These

⚠️

****Skimming past Claude's clarifying questions**  
Here's why this happens: you're eager to see the output, so you answer quickly with vague responses.  
The way I avoid it: treat those questions like a brief but important conversation. If Claude asks about team capacity, give it real numbers. If it asks about your launch timeline, give it a real date. Garbage in, garbage out.

⚠️

****Treating the roadmap as fixed**  
Here's why this happens: it looks like a finished document, so people treat it like one.  
The way I use it: this is a living document. As you build, you'll learn things that change your estimates and priorities. Update the roadmap when that happens, it's not a contract, it's a plan.

⚠️

****Design not actually being ready before dev starts**  
Here's why this happens: the roadmap shows design as "In Progress" for Sprint 2, dev starts Sprint 3, and you assume it'll be done in time. Then it isn't.  
The way I avoid it: design ready means design signed off and in Figma before the dev sprint starts, not "we're working on it." Treat the Design Ready column as a hard gate, not a status update.

---

## 6\. Practice

### Exercise 1: Generate Your Roadmap

**What to do:** Copy the prompt from Section 3.1 and run it in Claude Code. When Claude asks questions, answer them with real numbers, your actual team size, your actual sprint capacity, your target launch date. Navigate to `.project/implementation-roadmap.md` when it's done.

**A nudge if you're stuck:** If Claude isn't asking questions before writing, check that the last two lines of the prompt are included, the `ask user question tool` instruction is what triggers that behaviour. If it wrote the file without asking, re-read the roadmap and check if the capacity assumptions match your reality.

**How you'll know it's working:** You have a roadmap file with multiple phases, each ending at a natural shippable point, with sprint tables that include dependency and design-ready columns.

### Exercise 2: Audit the Release Checkpoints

**What to do:** Read the Release Checkpoints section. For each checkpoint, write one sentence (in the doc or in your own notes) describing what a user could actually do at that point. If you can't write that sentence, the checkpoint isn't real yet, note that and flag it.

**What this is practising:** Product thinking. The ability to translate engineering milestones into user value is one of the most useful skills you can build as a founder.

---

## 7\. You Should Be Able to Build This Now

With what we've covered in this lesson and the last one, you have:

- A Feature Priority Matrix telling you what to build and in what order
- An Implementation Roadmap telling you when to build it, with capacity constraints, design pipeline, and risk planning baked in

That combination is more rigorous planning than most small teams do. And it all lives in your project, tracked in version control, right next to your code.

### Check Yourself

- `.project/implementation-roadmap.md` exists in my project
- The capacity numbers in the Roadmap Overview match my actual team
- Design is scheduled at least one sprint ahead of the dev sprints it feeds
- Each phase ends at a clear, shippable point I can describe in one sentence
- I've read the Risk Register and I understand the top 2,3 risks going into the build

✅

If those are ticked, you're ready for the next lesson. The planning is done. We're going into the build phase, and we're going in prepared.

### If Something's Not Working

⚠️

****Claude wrote the roadmap without asking any questions**  
****What's happening:** The `ask user question tool` instruction didn't trigger, Claude may have had enough context to proceed, or the instruction was cut off.  
****How to fix it:** Review the roadmap and check whether the capacity and timeline assumptions are reasonable. If they're not, add a note to the prompt with your actual constraints and re-run.

⚠️

****The feature-priority-matrix.md file isn't found**  
****What's happening:** Claude can't locate the input file, either the path is wrong or the file doesn't exist yet.  
****How to fix it:** Check that `.project/feature-priority-matrix.md` exists (it should from Module 3, Lesson 4). If it doesn't, go back to Lesson 4 and generate it first.

---

## The Short Version

Here's what I want you to walk away with:

- **The RICE matrix tells you what, the roadmap tells you when**: they're two separate documents that work together. Don't skip either one
- **Design before dev, always**: plan for design to be a sprint ahead. Make it a hard gate, not a hope
- **Every phase ends with something shippable**: if you can't describe what a user can do at the end of a phase, that phase needs restructuring
- **What you can do now:** You have a full planning stack in your project, research → docs → specs → priority matrix → roadmap. That's your foundation for the build

---

## Quick Reference

### Output File Location

```
.project/implementation-roadmap.md

```

### Input File (Required)

```
.project/feature-priority-matrix.md

```

### Roadmap Structure

```
Roadmap Overview         → capacity, sprint cadence, team
Design-Dev Pipeline      → design lead time and deliverables
Phase N: [Name]          → theme, success criteria, design status
  Sprint N (Week X-Y)    → story table with estimates and dependencies
Risk Register            → risks, likelihood, impact, mitigation
Release Checkpoints      → what's shippable after each phase

```

### How to Run

1. Open terminal in WebStorm (`Cmd + E` → Terminal on Mac)
2. Run `claude` if not already running
3. Paste the prompt from Section 3.1
4. Answer Claude's clarifying questions with real numbers
5. Allow file writes when prompted
6. Navigate to `.project/implementation-roadmap.md` to review

---

## Resources

### Tools Used

- [Claude Code](https://claude.ai/download?ref=deletosh.com)
- [WebStorm by JetBrains](https://www.jetbrains.com/webstorm/?ref=deletosh.com)

---

## Questions I Get Asked

**Q: Do I need to update the roadmap as I build?**

Yes, and don't feel bad about it. The roadmap is a plan, and plans change as you learn things. If a feature takes twice as long as estimated, update the downstream sprints. If a dependency shifts, update the phases that depend on it. The document is most useful when it reflects reality, not when it perfectly matches what you wrote before you started.

**Q: What if I'm the only developer?**

Set your capacity accordingly, one developer, however many days per sprint you're realistically available. The maths still works. The roadmap will just show fewer stories per sprint, and that's honest. Better to plan for realistic capacity than to build a roadmap you'll never hit.

**Q: Can I skip the risk register section?**

You can, but I wouldn't. The risks Claude surfaces are usually the ones you already know about in the back of your head but haven't written down. Writing them down with likelihood and impact makes you take them seriously. The mitigation column is what matters most, it forces you to have a plan for things going wrong before they go wrong.

**Q: How do I know I'm ready for the next lesson?**

You've got a roadmap file, you've read it, and you can describe what's shipping at the end of each phase. That's all you need. The next lesson is where we move from planning to building.

---

## 💬 Stuck? Come Talk to Us

💡

If something's not clicking or you want to share what you've built, come find us in Discord.  
****Build What Ships community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community's active and I check in there too.

---

## Glossary

**Implementation Roadmap:** A phased, sprint-based delivery plan that translates the Feature Priority Matrix into a concrete build order, with capacity constraints, design pipeline, risk register, and release checkpoints. Saved as `.project/implementation-roadmap.md`. *(first introduced in Module 3, Lesson 5)*

**Sprint:** A fixed two-week development cycle. Each sprint has a defined set of stories to build, a capacity constraint (person-days available), and a set of dependencies that must be met before the sprint starts. *(first introduced in Module 3, Lesson 5)*

**Design-Dev Pipeline:** The practice of keeping design work at least one sprint ahead of development. Design deliverables (Figma files with approved UI/UX) must be complete before a story enters a dev sprint. *(first introduced in Module 3, Lesson 5)*

**Release Checkpoint:** A defined point at the end of each phase where the work completed so far is shippable to real users. Not just "code complete", something a user can actually get value from. *(first introduced in Module 3, Lesson 5)*

**Risk Register:** A table of identified risks, each with a likelihood rating, an impact rating, and a mitigation strategy. Included in the implementation roadmap to surface known risks before they become problems. *(first introduced in Module 3, Lesson 5)*

**Person-Days:** The unit of development capacity used in sprint planning. Calculated as: number of developers × working days per sprint. Determines how many stories can fit in a given sprint. *(first introduced in Module 3, Lesson 5)*
### Module 3, Lesson 4: Designing RICE
URL: https://deletosh.com/courses/product-path/03-04-design-rice/
Last updated: 2026-07-16T15:33:40.000Z
**How do you decide what to build first?** You score your features with RICE (Reach, Impact, Confidence, Effort), so priority comes from evidence, not from whatever feels exciting.

Claude Code reads your specs and generates a ranked Feature Priority Matrix saved to your project.

## What is RICE scoring?

RICE is a product prioritisation framework that scores each feature on four factors, Reach, Impact, Confidence, and Effort, then combines them into a single number so you can rank what to build first. It turns subjective opinions about which feature matters most into an objective, comparable list.

In this lesson you have Claude Code read your specs folder and generate a RICE-scored Feature Priority Matrix, saved as a file in your project, so your build order is grounded in your actual users and constraints.

In this lesson, I'm picking up right where we left off. We've got our specs in the project. Claude Code is installed. Now we need to answer the question that every product person, every founder, and honestly most engineers avoid asking until it's too late: what should we actually build first?

ℹ️

No corrections or updates from previous lessons to flag here, you're good to carry everything forward.

---

## Before We Start

Here's what I'd expect you to have in place before this lesson:

**From previous lessons:**

- Your `/specs` folder exists in the project with feature specs inside it, from Module 3, Lesson 2
- Claude Code is installed, authenticated, and you've confirmed it runs in your WebStorm terminal, from Module 3, Lesson 3
- You're comfortable opening the terminal in WebStorm and typing a prompt into Claude Code

**Tools / setup you'll need:**

- WebStorm open with your project loaded
- Claude Code running in the terminal (`claude` command works)
- Your specs folder populated, this is what Claude will read to generate the matrix

**By the end of this lesson, you'll:**

- Understand what RICE scoring is and why it matters for deciding what to ship first
- Know how to write a prompt that gets Claude Code to generate a Feature Priority Matrix from your specs
- Have a `.project/feature-priority-matrix.md` file saved in your project, a real, data-driven view of your features ranked by priority
- Understand how to read that output and actually use it to guide what you build next

---

## About This Lesson

**Duration:** \~12 minutes video + \~20 minutes practice  
**Skill Level:** Intermediate  
**What You'll Build:** A Feature Priority Matrix document saved in your project, RICE-scored features, hook analysis, dependency map, and a continuous deployment strategy.

This is still planning, not coding, and that's deliberate. The reason I put this lesson here is that most people jump to building whatever feature sounds most exciting, or whatever feels most technically interesting. RICE is how you stop doing that. It gives you a framework to make the decision objectively, based on your actual users and your actual constraints. The output of this lesson is one of the most valuable documents you'll have going into the build phase.

---

## Watch the Lesson

---

ℹ️

****How I'd suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section, pausing the video at the timestamps I've noted. After that, this guide is your reference, you shouldn't need to rewatch to look something up.

---

## What We're Covering

Here's what I'm walking you through in this lesson and why it matters:

- **Why you can't build everything at once**: this is obvious when you say it out loud, but most people don't act like it until they've wasted weeks building the wrong thing first
- **What RICE actually is**Reach, Impact, Confidence, Effort, and how the scoring formula turns fuzzy opinions into a ranked list
- **How to write the prompt**: the specific prompt structure that tells Claude Code what to generate and where to save it
- **How to read the output**: what the matrix tells you and how to make decisions from it
- **The hook analysis**: looking at your highest-scoring features and asking whether they're painkillers or vitamins, and whether they create habit loops
- **What comes next**: the RICE matrix tells you what has priority; the next lesson is about turning that into a delivery timeline

---

## 1\. Let's Set the Scene *(\~0:00)*

So I'm working through a project, and the first thing I always ask myself, and I've noticed it's the same question that trips up most people building software, is: what makes sense to do first? What makes sense to do next?

We've got our specs folder. We've got features documented. But we cannot do everything at once. We need to define what makes sense to ship first, and that's what this lesson is about.

This brings us to a concept that's fairly well-established in product management: **RICE**. Reach, Impact, Confidence, and Effort. It sounds technical but it's actually pretty intuitive once you see it in action. And the good news is, we're not going to fill out a spreadsheet manually, we're going to let Claude Code do the heavy lifting while we make the decisions.

🔥

In big companies, there are whole teams of product managers doing exactly this kind of analysis. You now have the framework, and the AI to run it, available to you as a solo builder. This is a genuinely unfair advantage. Use it.

---

## 2\. The Core Idea

### 2.1 What RICE Scoring Actually Is

RICE is a prioritisation framework. It stands for:

- **Reach**How many of your users does this feature affect in a given period?
- **Impact**How significantly does this feature move your key metric for the users it reaches?
- **Confidence**How confident are you in your Reach and Impact estimates? (This keeps you honest.)
- **Effort**How much work does it take to build? Typically measured in person-days.

The formula combines them into a single score:

```
RICE Score = (Reach × Impact × Confidence) ÷ Effort

```

The higher the score, the higher the priority. Features with a big reach, strong impact, and high confidence, but relatively low effort, float to the top. Features that are technically interesting but touch only a few users and require enormous effort sink to the bottom.

What this does is take the decision out of gut feeling and give you a number to point at. You can still override it, and sometimes you should, but at least you're overriding it with full awareness.

ℹ️

Think of Reach like how many people would notice if this feature disappeared tomorrow. Impact is how loudly they'd complain. Confidence is whether you actually believe those numbers, or you're just being optimistic. Effort is how long it takes to build. That combination gives you your score.

### 2.2 The Hook Analysis: Painkillers vs Vitamins

For your highest-scoring features, RICE alone isn't the whole story. There's a question worth asking for each one: is this feature a **painkiller** or a **vitamin**?

A painkiller solves an urgent, real problem. Users seek it out. They feel the absence immediately. A vitamin is nice to have, users appreciate it, but they won't churn without it.

Painkillers ship first. Every time.

The other thing we're looking for in this analysis is whether a feature creates a **habit loop**: does using this feature make users more likely to come back and use the product again? Features that create habit loops drive retention, which is ultimately the thing that keeps your product alive.

In the prompt I use for this lesson, I ask Claude to run a hook analysis on the high-scoring features to surface exactly these things. It's not fluff, it's the kind of thinking that separates products people use once from products people rely on.

### 2.3 How This Builds on Module 3, Lesson 2

In Module 3, Lesson 2, we wrote the feature specs and saved them to the `/specs` folder in the project. That folder is the input to everything we're doing in this lesson. The whole point of those specs existing in the codebase is that Claude Code can read them directly. We don't copy and paste anything manually. We just point Claude at the folder and let it work.

---

## 3\. Let Me Show You How It Works *(\~1:00)*

### 3.1 Setting Up a Scratch File (Optional but Useful)

Before I paste the prompt into Claude Code, I like to write it out first in a scratch file so I can read through it and make edits before running it. In WebStorm, I right-click in the file tree, create a new plain text file, and just call it something throwaway like `scratch`. No extension, just a temporary place to type.

This is optional, you can type directly into the Claude Code terminal. But I find it easier to compose longer prompts in a file first, then copy them across.

### 3.2 The Prompt

Here's the prompt I use to generate the Feature Priority Matrix. You have access to this, copy and paste it into Claude Code:

```text
Based on the spec requirements in the specs folder, create a Feature Priority Matrix document.

Write to: .project/feature-priority-matrix.md

Include these sections:

## 1. Scoring Criteria Definition
Define what Reach, Impact, Confidence, and Effort mean for [PRODUCT NAME]:
- Reach: [Our target user base for Q1 is X users]
- Impact: Map to our key metric [e.g., time reduction, engagement rate]
- Effort: Dev time only in person-days (design tracked separately)

## 2. RICE Scoring Table
| Feature | Reach | Impact | Confidence | Effort | RICE Score |
|---------|-------|--------|------------|--------|------------|

## 3. Hook Analysis
For each high-scoring feature, analyze:
- What makes this feature "sticky" for users?
- Is this a painkiller (solves urgent problem) or vitamin (nice to have)?
- Does this create a habit loop?

## 4. Dependency Map
Which features must be built first due to technical dependencies?

## 5. Continuous Deployment Strategy
How will we deliver incremental value every 2-week sprint?

Additionally, where relevant, do additional web search for context with the web search tool and ask me additional questions for clarity with the ask question tool.

```

⚠️

****Replace the placeholders before you run this.** Fill in your product name, your Q1 user target, and your key metric. The more specific you are in those definitions, the more accurate and useful the scoring will be. Vague inputs get vague outputs.

### 3.3 Pasting and Running in Claude Code

Open your terminal in WebStorm (Cmd + E → Terminal on Mac, or Ctrl + E on Windows), and if Claude Code isn't already running, type `claude` to start it.

Paste the prompt and hit enter.

You'll likely see a message asking whether Claude can make changes to your files for this session. When that appears, say **yes to all edits for the session**. You don't want Claude asking permission before every file write. Once you've allowed it, it will do its thing.

Claude will:

1. Read your specs folder
2. Potentially ask you clarifying questions (this is what the `ask question tool` instruction does, it's built into Claude Code)
3. Potentially do some web research for market context (the `web search tool` instruction handles this)
4. Write the completed matrix to `.project/feature-priority-matrix.md`

When it's done, navigate to that file in your project folder. You should have a Markdown document waiting for you.

### 3.4 What's Going On Under the Hood

The reason this prompt works so well is the combination of things we're asking Claude to do:

- It reads your spec files directly from the project, it's not guessing, it's working from your actual documented features
- It applies a well-established framework (RICE) with real numbers, not just opinions
- It goes beyond the score to ask whether features are sticky and habit-forming, this is product thinking, not just engineering prioritisation
- It maps technical dependencies so you're not accidentally trying to build something that requires something else to exist first
- It thinks in sprints, because the point is to ship incrementally, not in one big release

---

## 4\. Reading the Output

The matrix Claude produces will be specific to your product and your specs. Here's what to look for when you read it:

**In the Scoring Criteria section**: check that the definitions make sense for your context. RICE is flexible; the numbers only mean something relative to each other and relative to your user base. If Claude's definitions feel off, adjust them and re-run.

**In the RICE Scoring Table**: look at the top 3,5 features by score. These are your priorities. Then look at the bottom. If anything surprises you at either end, that's worth thinking about, sometimes the model catches something you'd been underweighting.

**In the Hook Analysis**: this is the one I find most valuable to actually read carefully. It'll tell you which of your high-scoring features are true painkillers, and which are nice-to-haves that scored well on reach but don't drive retention. The ones that create habit loops and have high switching costs, those are your moat. Build them early and build them well.

**In the Dependency Map**: treat this as a constraint layer on top of the RICE scores. A feature might score high, but if it technically depends on something else that needs to be built first, that dependency takes precedence. This is your build order.

ℹ️

Authentication and onboarding tends to score very high in RICE analyses like this, even though it can feel like a boring feature to build. The reason: it has 100% reach (you can't use the product without it), high confidence (everyone agrees it's needed), and the impact is absolute, if you can't log in, nothing else matters. Take that signal seriously.

---

## 5\. Watch Out For These

⚠️

****Treating the RICE score as the final word**  
Here's why this happens: the framework feels authoritative, so people stop thinking once they see the numbers.  
The way I use it: RICE is a data point, not a decree. Read the scores, understand what's driving them, and then apply your own judgement. If something feels wrong, dig into the scoring criteria, the numbers are only as good as the inputs.

⚠️

****Vague scoring criteria giving vague results**  
Here's why this happens: if you leave the placeholders as \[PRODUCT NAME\] or don't define what your key metric is, Claude will make reasonable guesses, but they won't be grounded in your actual context.  
The way I avoid it: spend five minutes filling in the criteria definitions before you run the prompt. Be specific about your user target and your success metric. Everything flows from there.

⚠️

****Forgetting to allow file writes when Claude asks**  
Here's why this happens: the first time Claude Code is about to write a file in a session, it checks in before proceeding.  
The way I handle it: when you see the permission prompt, choose "yes to all for this session." Otherwise Claude will ask before every file change and it gets tedious fast.

---

## 6\. Practice

### Exercise 1: Generate Your Matrix

**What to do:** Copy the prompt from Section 3.2, fill in your product name, user target, and key metric, then run it in Claude Code. Navigate to `.project/feature-priority-matrix.md` and open the file.

**A nudge if you're stuck:** If Claude asks you clarifying questions before writing the file, answer them specifically. That's the `ask question tool` doing exactly what it's supposed to, use it, don't skip past it.

**How you'll know it's working:** You have a `.project/feature-priority-matrix.md` file with all five sections populated, and the RICE scoring table has a row for every feature from your specs folder.

### Exercise 2: Read the Hook Analysis and Mark Your Painkillers

**What to do:** Open the Hook Analysis section of the document. For each feature listed, manually note in the file (or just in your own notes) whether you agree with Claude's classification. Put a ✅ next to the ones you're confident are genuine painkillers. Put a ❓ next to anything you're not sure about.

**What this is practising:** Critical thinking about your own product. The AI gives you the framework, but you know your users. Trust your instincts when something doesn't feel right.

---

## 7\. You Should Be Able to Build This Now

Here's what you can do with what we just covered:

- Generate a data-driven feature priority ranking from any set of documented specs
- Identify which features are genuine painkillers vs nice-to-haves
- Map technical dependencies before you start building so you don't back yourself into a corner
- Walk into the next lesson with a clear, prioritised list, not a hunch

### Check Yourself

- `.project/feature-priority-matrix.md` exists in my project
- The RICE Scoring Table has a row for each feature in my specs folder
- I've read the Hook Analysis and I understand which features are my highest-value priorities
- I've checked the Dependency Map and I know which features need to come first for technical reasons

✅

If those are ticked, you're ready for the next lesson, where we take the RICE matrix and turn it into a proper delivery timeline. The planning phase is almost done. Build phase is close.

### If Something's Not Working

⚠️

****Claude wrote the file but it's empty or incomplete**  
****What's happening:** Claude may have been waiting for your answers to clarifying questions and timed out, or the specs folder is empty / not where it expected.  
****How to fix it:** Check that your `/specs` folder has files in it. Then re-run the prompt, and when Claude asks questions, answer them fully before it proceeds to write.

⚠️

****The** **`.project`** **folder doesn't exist**  
****What's happening:** Claude will usually create it, but if it ran into a permissions issue it may not have.  
****How to fix it:** Create the `.project` folder manually in your project root (right-click in WebStorm → New Directory → `.project`), then re-run the prompt.

---

## The Short Version

Here's what I want you to walk away with:

- **RICE = Reach × Impact × Confidence ÷ Effort**: a score that ranks your features by actual priority, not gut feel or enthusiasm
- **Painkillers before vitamins**: features that solve urgent problems ship first, every time. The hook analysis helps you tell them apart
- **Dependencies constrain order**: a feature might score high, but if it needs something else to exist first, that something else comes first
- **What you can do now:** You have a Feature Priority Matrix in your project, a document that tells you what to build first and why. The next lesson turns that into a timeline

---

## Quick Reference

### The RICE Formula

```
RICE Score = (Reach × Impact × Confidence) ÷ Effort

```

### Output File Location

```
.project/feature-priority-matrix.md

```

### How to Run the Prompt

1. Open terminal in WebStorm (`Cmd + E` → Terminal on Mac)
2. Run `claude` if not already running
3. Paste the prompt (with placeholders filled in)
4. Allow file writes when prompted
5. Navigate to `.project/feature-priority-matrix.md` to review the output

---

## Resources

### Links & Docs

- [RICE Scoring, Intercom's original writeup](https://www.intercom.com/blog/rice-simple-prioritization-for-product-managers/?ref=deletosh.com)this is where the framework was popularised; worth reading for the rationale behind each component

### Tools Used

- [Claude Code](https://claude.ai/download?ref=deletosh.com)
- [WebStorm by JetBrains](https://www.jetbrains.com/webstorm/?ref=deletosh.com)

---

## Questions I Get Asked

**Q: Do I have to use RICE, or can I use a different framework?**

RICE is what I use and what I've found works well, the formula is simple and the output is a ranked list you can actually act on. If you have a different framework you trust, use it. The point is to make the decision with data rather than vibes. What matters is that you have a defensible reason for your build order before you start coding.

**Q: What if Claude's scoring feels off for my product?**

That's normal, and it's actually useful information. If a feature is scoring high but your instinct says it shouldn't, dig into the criteria definitions. Usually the issue is that Reach or Impact was defined too broadly. Tighten up the definitions, re-run, and see if it changes. If it still feels off after that, trust your domain knowledge, but be honest with yourself about whether you're overriding the data for good reasons.

**Q: Can I run this with Claude Desktop instead of Claude Code?**

Technically yes, you could paste the same prompt into Claude Desktop with the JetBrains MCP active. But Claude Code reads the specs folder directly, which means it's working from your actual files rather than you copying and pasting them in. Use Claude Code here.

**Q: How do I know I'm ready for the next lesson?**

You've got your matrix file, you've read it, and you understand which features are top priority and in what order they need to be built. That's all you need.

---

## 💬 Stuck? Come Talk to Us

💡

If something's not clicking or you want to share what you've built, come find us in Discord.  
****Build What Ships community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community's active and I check in there too.

---

## Glossary

**RICE Scoring:** A feature prioritisation framework. Stands for Reach, Impact, Confidence, and Effort. The score is calculated as (Reach × Impact × Confidence) ÷ Effort. Higher score = higher priority. *(first introduced in Module 3, Lesson 4)*

**Reach:** In RICE, the number of users a feature affects in a given time period. Usually expressed as a count or a percentage of your active user base. *(first introduced in Module 3, Lesson 4)*

**Impact:** In RICE, how much a feature moves your key metric for the users it reaches. Often scored on a scale (e.g., 0.25 = minimal, 0.5 = low, 1 = medium, 2 = high, 3 = massive). *(first introduced in Module 3, Lesson 4)*

**Confidence:** In RICE, how certain you are about your Reach and Impact estimates. Expressed as a percentage (100% = fully confident, 50% = educated guess). Keeps you honest about assumptions. *(first introduced in Module 3, Lesson 4)*

**Effort:** In RICE, the total person-days required to design, build, and test a feature. Lower effort with high reach/impact/confidence = higher priority. *(first introduced in Module 3, Lesson 4)*

**Painkiller (feature):** A feature that solves an urgent, existing problem for users. Users actively seek it out and feel its absence immediately. Contrast with vitamins. *(first introduced in Module 3, Lesson 4)*

**Vitamin (feature):** A feature that's nice to have, appreciated when present, but users won't churn without it. Lower priority than painkillers. *(first introduced in Module 3, Lesson 4)*

**Habit Loop:** A product pattern where using a feature increases the likelihood that a user will return and use the product again. Features that create habit loops drive retention. *(first introduced in Module 3, Lesson 4)*

**Feature Priority Matrix:** The output document from this lesson, a structured analysis of all features ranked by RICE score, with hook analysis, dependency map, and deployment strategy. Saved as `.project/feature-priority-matrix.md`. *(first introduced in Module 3, Lesson 4)*
### Module 3, Lesson 3: Installing Claude Code
URL: https://deletosh.com/courses/product-path/03-03-install-claude-code/
Last updated: 2026-07-16T15:33:38.000Z
**How do you install Claude Code?** You install it with one command in the WebStorm terminal (on Windows, inside WSL), then log in once to connect it to your Claude account.

After that it runs inside your project, reading files and writing code with no copy and paste.

## What is Claude Code and how is it different from Claude Desktop?

Claude Code is an agentic coding tool: it runs in the terminal inside your project folder, knows your codebase, and can read, write, and edit code autonomously. That is the key difference from Claude Desktop, which lives in its own window and reaches into your editor over MCP.

In this lesson you install Claude Code, authenticate it with your Claude account, and verify it runs from the WebStorm terminal so it is ready for the rest of Module 3 and Module 4.

At this point you should have your specs out and saved in your project via WebStorm. If you followed along in the previous lesson, you've got a `/specs` folder with feature requirements sitting in your codebase. Now we're about to add the most powerful tool in this whole course.

In this lesson, we're installing Claude Code, and this is the point where things get genuinely exciting.

ℹ️

****One thing to note:** In the video, I walk through an npm-based installation. Since that recording, Anthropic has updated the recommended install method to use a ****native installer** , one command, no Node.js required, auto-updates in the background. I'll show you both, but I'd recommend the native installer. The steps and the outcome are the same either way.

---

## Before We Start

Here's what I'd expect you to have in place before this lesson:

**From previous lessons:**

- WebStorm installed, project created, and MCP connected to Claude Desktop, from Module 3, Lesson 1
- Your `/specs` folder exists in the project, from Module 3, Lesson 2
- You're comfortable opening the terminal inside WebStorm (we'll use it here)

**Tools / setup you'll need:**

- WebStorm open with your project loaded
- A working internet connection
- On Windows: Windows 10 or 11 (WSL is required, covered below)

**By the end of this lesson, you'll:**

- Have Claude Code installed and ready to run from the WebStorm terminal
- Be logged in and authenticated with your Claude Pro account
- Know that it's working and be set up for everything that follows in Module 3 and 4

---

## About This Lesson

**Duration:** \~9 minutes video + \~15 minutes setup  
**Skill Level:** Intermediate  
**What You'll Build:** A working Claude Code installation inside your WebStorm terminal, your agentic coding environment, ready to go.

This is a short setup lesson, but it's a big transition. Everything we've done so far, the research, the docs, the specs, has been building toward this moment. Claude Code is the tool that's going to take all that planning and actually turn it into a working product. Take your time with the setup here. Five minutes of patience now saves hours of friction later.

---

## Watch the Lesson

---

ℹ️

****How I'd suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section, pausing the video at the timestamps I've noted. After that, this guide is your reference, you shouldn't need to rewatch to look something up.

---

## What We're Covering

Here's what I'm walking you through in this lesson:

- **What Claude Code actually is**"agentic coding tool" is the technical label, but I'll tell you what it actually means for how we work
- **Installing on Mac**: the one-command install and how to verify it's working
- **Installing on Windows**: why WSL is the right path and what that setup looks like
- **Authenticating with your Claude account**: the one-time login flow that ties Claude Code to your Pro subscription
- **Verifying it's all working**: what a successful install looks like before we move on

---

## 1\. Let's Set the Scene *(\~0:00)*

At this point, we've got our specs out and saved in the project via WebStorm. In the previous lesson, we got a few of them done together. I hope you're excited, because we are about to talk about something even more exciting.

Up until now, we've been using Claude Desktop to control JetBrains via MCP. From this lesson forward, we're going to move slowly but completely into working from inside JetBrains itself, that's going to be our main sandbox. And the tool that makes that possible is Claude Code.

Claude Code is what's called an agentic coding tool. That's a lot of lingo for something that, at its core, just means: a tool that assists you in writing a lot of code, and does it *autonomously*, inside your actual project. Unlike Claude Desktop (which lives in its own window and reaches into your editor via MCP), Claude Code runs directly in the terminal *inside* your project folder. It knows your codebase, it can read your files, and it can write and edit code without you having to copy and paste anything.

There's also a lot more you can do with Claude Code beyond just writing code. We'll see that over the next few lessons.

For now, all we need to do in this lesson is get it installed.

🔥

This is the turning point in the course. Everything from Module 1 and 2 was prep work. Claude Code is how we actually build. Installation is all that stands between you and that.

---

## 2\. The Core Idea

### 2.1 What Makes Claude Code Different from Claude Desktop

We've been using Claude Desktop since Module 1\. It's great, and we'll still use it for certain things. But there's a key difference when it comes to building.

Claude Desktop is like having a very capable assistant sitting next to you. You talk to it, it gives you things back, and you bring those things into your project manually (or via MCP). That works well for research, documentation, and planning.

Claude Code is different. It runs *inside* your terminal, *inside* your project. When you give it a task, it can read your files directly, understand the context of your whole codebase, write new code, edit existing code, and run commands, all without you acting as the middleman. It's not a chatbot you consult. It's more like a junior developer who already has access to your repo and is sitting at the keyboard.

That's what "agentic" means in practice: it takes action, not just advice.

ℹ️

Claude Desktop and Claude Code aren't mutually exclusive, they complement each other. Desktop is great for planning, docs, and high-level orchestration. Code is where the building happens. We'll use both throughout the rest of this course.

### 2.2 What You Need Before You Can Install

One important thing: Claude Code requires a **paid Claude account** to authenticate. Your Claude Pro subscription covers this, you don't need a separate API key. We'll walk through the login step after installation.

---

## 3\. Let Me Show You How It Works

### 3.1 Opening the Terminal in WebStorm

Everything we're about to do happens in the terminal inside WebStorm. If you haven't used it before, here's how to open it:

- **Mac:** Press `Cmd + E`, then click **Terminal**
- **Windows:** Press `Alt + E`, then click **Terminal**

It opens a panel at the bottom of WebStorm. It might look a bit different from mine depending on your setup, that's fine. This is where we type commands that interact with your system directly.

ℹ️

If the terminal looks intimidating, don't let it put you off. You'll spend a lot of time here over the next few modules, and Claude Code makes it genuinely enjoyable. By the time we're done you'll feel right at home in it.

### 3.2 Installing on Mac (Recommended Method)

Head to [claude.ai/download](https://claude.ai/download?ref=deletosh.com) or search for "Claude Code", you'll find the install page. The page will detect your operating system and show you the relevant command.

The current recommended install command for Mac (and Linux) is:

```bash
curl -fsSL https://claude.ai/install.sh | bash

```

Copy that command, paste it into your WebStorm terminal, and hit enter. It'll run, install Claude Code, and tell you when it's done. You're looking for an **"Installation complete"** message (or similar). If you see that, you're good.

💡

The native installer is self-contained, no Node.js required, and it auto-updates in the background. You won't need to reinstall to get new versions.

Once it's installed, verify it worked by running:

```bash
claude --help

```

If you see a list of available commands and options come back, you're installed and ready.

To clear the terminal screen after that, run:

```bash
clear

```

(Or on Mac: `Ctrl + L`)

### 3.3 Installing on Windows

If you're on Windows, there are two solid options:

**Option A, Native Windows Installer (simplest)**

Open PowerShell and run:

```powershell
irm https://claude.ai/install.ps1 | iex

```

This is the native Windows installer. It doesn't require WSL or Node.js, it installs a standalone binary directly. This is the simplest path if you're on Windows 10 or 11.

**Option B, WSL (Windows Subsystem for Linux)**

This is the path I walk through in the video, and it's still a solid option, especially if you plan to do more development work. WSL gives you a Linux environment running inside Windows, which means you get a Mac-like development experience on your Windows machine.

To install WSL, open PowerShell as an administrator and run:

```powershell
wsl --install

```

This installs WSL along with an Ubuntu distribution. After that, you'll install Claude Code from inside your WSL terminal using the same curl command as Mac:

```bash
curl -fsSL https://claude.ai/install.sh | bash

```

I've linked a comprehensive WSL setup guide in the Resources section below if you need help with this step. It walks you through everything, including Git setup.

⚠️

****Windows users, common mistake:** If you go the WSL route, make sure you're running everything from inside the WSL terminal (your Linux terminal), not from a Windows Command Prompt or PowerShell. Node.js installed on the Windows side won't be visible inside WSL. Run everything from within the Linux environment.

Once you're set up on either path, verify the install the same way:

```bash
claude --help

```

---

## 4\. Logging In and Authenticating *(\~6:20)*

Once Claude Code is installed, the first time you run it, it needs to connect to your Claude account. Here's how to do that.

In the terminal, run:

```bash
claude auth login

```

This will open your browser. Make sure you're already logged into Claude in that browser before you run this. It'll prompt you to authorise Claude Code, say yes, authorise it, and then you'll see a "Let's build something great" message in the browser. Close that and go back to your terminal.

In the terminal, you should see: **Login successful.**

Now type:

```bash
claude

```

It'll ask whether you trust the current folder (it's about to be able to make changes to it). Say yes.

If everything's wired up correctly, you'll see a welcome screen that tells you:

- You're logged in as Claude Pro
- Your name
- The name of the project you're in

That's it. Claude Code is running and ready.

✅

When you see the welcome screen with your name and project, you're done. Claude Code is installed, authenticated, and ready for the rest of the course.

---

## 5\. Optional: The JetBrains Plugin *(\~8:00)*

After logging in, Claude Code might prompt you to install the JetBrains Claude Code plugin. You can install it if you want, it adds a UI panel inside WebStorm for interacting with Claude Code visually.

That said, most of what we'll do going forward will be typed directly into the terminal. I find you get a better experience and more control that way, so I'll be teaching from the terminal throughout. But it's available if you want it, you can click the link Claude provides and it'll walk you through the plugin installation.

---

## 6\. Try It Yourself

### Verify the Installation End-to-End

Work through these steps in order:

1. Open your WebStorm terminal (`Cmd/Alt + E` → Terminal)
2. Run the install command for your OS (see Section 3 above)
3. Confirm installation with `claude --help`
4. Run `claude auth login` and complete the browser auth flow
5. Run `claude` in your project directory and confirm the welcome screen appears

**What success looks like:** You see the Claude welcome screen with your name, your subscription level (Claude Pro), and your project name.

**Now try this:** Type a simple message to Claude Code, something like `hello, what files do you see in this project?`and see how it responds. This confirms Claude can actually read your project, not just that the installation ran.

---

## 7\. Watch Out For These

⚠️

****Mac: "command not found" after installation**  
Here's why this happens: the installer added Claude Code to your PATH, but your terminal session hasn't picked up the change yet.  
The way I fix it: close the terminal tab inside WebStorm and open a new one, then try `claude --help` again. That usually sorts it.

⚠️

****Windows: Installing from the wrong environment**  
Here's why this happens: if you're using WSL, you need to run the install command from inside the WSL (Linux) terminal. If you accidentally run it from a Windows path or CMD, it won't work.  
The way I avoid it: before running anything, check that your terminal prompt shows a Linux-style path (like `~/yourproject`), not a Windows path (like `C:\Users\...`).

⚠️

****Auth flow doesn't complete**  
Here's why this happens: your browser wasn't logged into Claude before you ran `claude auth login`, or you closed the browser before completing the authorisation.  
The way I fix it: log into claude.ai in your browser first, then run `claude auth login` again from the terminal.

🚨

****Don't use a Claude API key for authentication here**  
Claude Code authenticates via your Claude Pro account, not an API key. The auth flow opens your browser and logs you in the same way Figma's MCP did. If you paste an API key into the terminal, it won't work. Use `claude auth login` and go through the browser.

---

## 8\. Practice

### Exercise 1: Get Installed and Running

**What to do:** Complete the full installation and authentication flow for your operating system. Verify with `claude --help`, then log in and confirm the welcome screen.

**A nudge if you're stuck:** Most issues at this step come from either (a) the terminal not picking up the new PATH, or (b) the browser not being logged in before the auth step. Check both of those before anything else.

**How you'll know it's working:** You see the Claude welcome screen showing you're logged in as Claude Pro, with your project name visible.

### Exercise 2: Say Hello

**What to do:** Once Claude Code is running, type a message and see what comes back. Try: `what does this project contain so far?`

**What this is practising:** Getting familiar with how Claude Code's conversational interface works inside the terminal. It's different from Claude Desktop, you're inside the project, and Claude can see everything.

---

## 9\. You Should Be Able to Build This Now

Here's what you've got now:

- Claude Code installed and running inside your WebStorm terminal
- Authenticated with your Claude Pro account, no API key needed
- A working agentic coding environment sitting inside your actual project

### Check Yourself

- `claude --help` returns a list of commands
- I've completed the auth flow and seen "Login successful"
- Running `claude` in my project directory shows the welcome screen with my name and Claude Pro status
- I've sent a test message and Claude responded correctly

✅

If those boxes are ticked, you're properly set up and ready for the next lesson. That's where we start putting Claude Code to work, wearing the hat of a product manager and letting Claude take on the heavy lifting. Nice work getting here.

### If Something's Not Working

⚠️

****The installation completed but** **`claude`** **doesn't run**  
****What's happening:** The binary was installed but your shell doesn't know where to find it yet.  
****How to fix it:** Close the terminal tab in WebStorm, open a new one, and try again. If that doesn't work, restart WebStorm entirely. Still no luck? Drop a screenshot in Discord and we'll help.

---

## The Short Version

Here's what I want you to walk away with:

- **Claude Code is an agentic coding tool**: it runs inside your terminal, inside your project, and can read and write your codebase directly. It's not a chat window; it takes real action.
- **One command installs it**`curl -fsSL https://claude.ai/install.sh | bash` on Mac/Linux; the PowerShell command on Windows. No Node.js required.
- **Windows users: two valid options**: the native PowerShell installer is the simplest. WSL is great if you want a full Linux development environment.
- **Authenticate with your Claude Pro account**: run `claude auth login`, go through the browser, done. No API key.
- **What you can do now:** Claude Code is ready to go. In the next lesson we're going to put it to work.

---

## Quick Reference

### Install Commands

```bash
# Mac / Linux / WSL
curl -fsSL https://claude.ai/install.sh | bash

# Windows (PowerShell — native installer)
irm https://claude.ai/install.ps1 | iex

```

### Verify Installation

```bash
claude --help

```

### Authenticate

```bash
claude auth login

```

### Open Claude Code in Your Project

```bash
claude

```

### Clear the Terminal

```bash
clear
# or on Mac: Ctrl + L
# or in WebStorm: Ctrl + L

```

---

## Resources

### Links & Docs

- [Claude Code, official download](https://claude.ai/download?ref=deletosh.com)always check here for the latest install command
- [Claude Code docs](https://code.claude.com/docs?ref=deletosh.com)official documentation
- [Comprehensive Guide to Setting Up Claude Code on Windows Using WSL](https://medium.com/ai-insights-cobet/comprehensive-guide-to-setting-up-claude-code-on-windows-using-wsl-d3a3f3b5a128?ref=deletosh.com)

### Tools Used

- [Claude Code](https://claude.ai/download?ref=deletosh.com)
- [WebStorm by JetBrains](https://www.jetbrains.com/webstorm/?ref=deletosh.com)

---

## Questions I Get Asked

**Q: Do I need a separate Claude API key for Claude Code?**

No, and this trips people up. Claude Code authenticates via your Claude Pro subscription, the same account you use at claude.ai. Run `claude auth login`, it opens your browser, you authorise it, done. You don't need to generate an API key from the console.

**Q: Can I use VS Code instead of WebStorm for the terminal?**

Yes. VS Code has a built-in terminal too, open it with Ctrl + \` (backtick). Everything I'm doing in the WebStorm terminal maps directly across. The terminal is just a terminal; which editor it lives in doesn't matter.

**Q: Does Claude Code cost extra on top of my Claude Pro subscription?**

No. Claude Code is included in your Claude Pro plan. That's why I recommend authenticating with your Pro account rather than using API credits, you get the same model without paying per token.

**Q: How do I know I'm ready for the next lesson?**

If you've seen the welcome screen with your name and Claude Pro status after running `claude`, you're ready. That's the bar.

---

## 💬 Stuck? Come Talk to Us

💡

If something's not clicking or you want to share what you've built, come find us in Discord.  
****Build What Ships community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community's active and I check in there too.

---

## Glossary

**Claude Code:** Anthropic's agentic coding tool. It runs in your terminal, inside your project folder, and can read files, write code, run commands, and work through tasks autonomously. Unlike Claude Desktop, it doesn't need to reach into your editor via MCP, it's already inside the project. *(first introduced in Module 3, Lesson 3)*

**Agentic (coding tool):** A tool that takes action on your behalf rather than just giving you advice. An agentic tool can make changes, run commands, and work through multi-step tasks without you acting as the intermediary at each step. *(first introduced in Module 3, Lesson 3)*

**WSL (Windows Subsystem for Linux):** A feature in Windows 10/11 that lets you run a full Linux environment alongside Windows. For developers on Windows, it provides a Mac-like development experience, tools like Claude Code that require a Unix-based environment work natively inside WSL. *(first introduced in Module 3, Lesson 3)*

**Terminal:** The command-line interface where you type text commands that interact directly with your system. In WebStorm, you open it with `Cmd + E` (Mac) or `Alt + E` (Windows) and selecting Terminal. It's where Claude Code lives. *(first used in Module 3, Lesson 1)*
### Module 3, Lesson 2: Writing the Spec with Claude Desktop
URL: https://deletosh.com/courses/product-path/03-02-writing-spec-claude/
Last updated: 2026-07-16T15:33:37.000Z
**How do you write a spec with Claude Desktop?** You point Claude at the docs you built in Module 2, then have it turn them into structured feature specs, written into your project as files.

The result is a /specs folder your codebase gets built from, not a note or a Slack message.

## What is a feature spec and why does it live inside the codebase?

A feature spec is a structured statement of what a product feature must do, organised by capability domain (what the product does) rather than by screen or feature name.

It lives inside the codebase, in a /specs folder in the project, so every build decision is grounded in a document that sits next to the code instead of scattered across Notion or Obsidian. In this lesson Claude Desktop reads your Module 2 documentation over MCP and writes those specs into your project for you.

In this lesson, we're picking up right where Lesson 1 left off. You've got WebStorm running, Claude Desktop connected via MCP, and a project folder sitting there waiting. Now we're going to use all that documentation we built in Module 2, the research, the UX/UI doc, the technical document, the user flow, and turn it into a structured set of feature specs written directly into the project.

ℹ️

No corrections or updates to previous lessons to flag before we start.

---

## Before We Start

Here's what I'd expect you to have in place before this lesson:

**From previous lessons:**

- WebStorm is installed, a project is created, and you know where it lives on your machine, we covered this in Module 3, Lesson 1
- MCP is enabled in WebStorm and Claude Desktop is connected, also from Module 3, Lesson 1
- You've run the connection test and it worked (Claude could list your project files using the JetBrains tool)
- Your Module 2 documentation should be complete and accessible in Obsidian: market research summary, PRD, technical document, UX/UI document, and your Figma user flow

**Tools / setup you'll need:**

- Claude Desktop (with JetBrains MCP connected)
- WebStorm open with your project loaded
- Your Obsidian vault with the documents from Module 2
- Your Figma user flow diagram from Module 2, Lesson 7

**By the end of this lesson, you'll:**

- Understand what a feature spec is and why it lives inside the codebase
- Have a working prompt that turns your existing documentation into structured specs
- Have a `/specs` folder in your project with actual spec files written by Claude, ready for development

---

## About This Lesson

**Duration:** \~15 minutes video + \~20 minutes practice  
**Skill Level:** Intermediate  
**What You'll Build:** A `/specs` folder in your WebStorm project containing structured feature requirements, generated by Claude from your Module 2 documentation and Figma user flow.

This is the lesson where things start to feel real. We've spent Module 2 building a solid foundation, research, documentation, user flows. Now Claude's going to read all of that and turn it into something developers (or Claude itself, later on) can actually work from. By the end of this lesson, your codebase isn't empty anymore. It has a spec.

---

## Watch the Lesson

---

ℹ️

****How I'd suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section, pausing at the timestamps I've noted. After that, this guide is your reference, you shouldn't need to rewatch to look something up.

---

## What We're Covering

Here's what I'm walking you through in this lesson:

- **Why specs live inside the codebase**: not in Notion, not in Obsidian, but in the project folder itself
- **The prompt that drives everything**: the exact prompt I use to take Claude from documentation to structured specs
- **How Claude reads your existing docs**: market research, UX/UI doc, technical doc, and the Figma flow all feed in together
- **Capability domains**: how to think about organising your specs by what the product *does*, not by screen or feature name
- **The spec quality checklist**: the four criteria that make a spec actually useful vs just words in a file

---

## 1\. Let's Set the Scene *(\~0:00)*

At this point in the course, you've been introduced to several tools and we've been using them to draft things. Claude has been at the centre of all of it. We used Obsidian to capture documentation, Figma to map out the user journey. And if you've been keeping up with everything, you should have a lot of that documentation all set.

Now we're moving into the bit where that documentation stops being research and starts being a *build plan*. This is the bridge, from "here's what we're making and why" to "here's what needs to exist, precisely, so we can build it."

The output of this lesson is a `/specs` folder sitting inside your project. Feature requirements, structured by capability domain, written directly into your codebase. From this point forward, every decision about what to build is grounded in a document, not a memory, not a Slack message, not a vague instruction to Claude. A spec.

ℹ️

I want to flag something here: this might feel like more planning before we get to building. It is. But every time I've skipped this step, or half-done it, I've paid for it later. The specs make the coding phase significantly faster and cleaner. Trust the process.

---

## 2\. The Core Idea

### 2.1 Why Specs Live Inside the Codebase

Here's something a lot of people get wrong: specs end up in Notion, or Google Docs, or Obsidian, detached from the actual project. The problem is that the moment you start building, those documents drift. Things change, and nobody remembers to update the doc.

I do it differently. From day one, the specs live inside the project folder, in a `/specs` directory. They're committed alongside the code. When Claude is working on a feature, it can read the spec directly from the same place as the code. There's no context-switching, no hunting for the "real" version of the requirements.

This is exactly what the JetBrains MCP connection enables. Claude can reach into your project folder and write those spec files directly. You're not copying and pasting, Claude is writing them to the right place, in the right structure, from the start.

### 2.2 Capability Domains vs Features

When you're writing specs, there's a temptation to organise them by screen or by feature name. "The login screen." "The dashboard." But I find that breaks down quickly because a lot of capabilities cut across multiple screens.

Instead, I organise by **capability domain**: the things the product needs to *do*. For a product like Nurturo, that might be things like: User Authentication, Onboarding, Content Delivery, Progress Tracking, Notifications. Each domain gets its own spec file. Within each spec, you cover the happy path (what happens when everything works) and the error cases (what happens when it doesn't).

This makes the specs reusable. If I'm asking Claude to build the authentication flow, I point it at the Authentication spec. It doesn't need to wade through everything else.

### 2.3 What Makes a Good Spec

I use a simple four-point checklist for every spec file before I consider it done:

1. **Scenarios are testable**: specific inputs lead to specific, verifiable outputs. "User sees confirmation email" is not testable. "User receives an email to the address provided within 60 seconds of registration" is.
2. **Error cases are documented**: what happens when the happy path breaks? Missing fields, network failures, duplicate accounts. If it's not in the spec, Claude won't handle it.
3. **No implementation details**: the spec says *what* the product does, not *how* it does it. No database schemas, no function names. Just behaviour.
4. **Cross-references between related specs**: if the onboarding flow depends on the authentication flow, say so. Claude (and future-you) will thank you.

💡

Think of specs like a contract between you and whoever is building the thing, whether that's Claude or a human developer. A good contract is specific enough that both sides know what success looks like, but doesn't tell the builder how to do their job.

---

## 3\. Let Me Show You How It Works *(\~varies)*

### 3.1 The Setup: What Claude Needs to Read

Before running the spec-generation prompt, I make sure Claude has access to the right documents. In my case, those are all in my Obsidian vault, and Claude can reach them via the MCP connection we set up in Module 2.

The documents I feed in are:

- **Market Research**: the full research output from Module 2, Lesson 1
- **Summary**: the distilled market analysis
- **Technical Document**: the technical spec generated in Module 2, Lesson 3
- **UX/UI Document**: the UX/UI documentation from Module 2, Lesson 4
- **Figma User Flow**: the user journey diagram from Module 2, Lesson 7

The combination of all of these gives Claude everything it needs: market context, technical constraints, UX intent, and a visual map of how users move through the product.

### 3.2 The Prompt

Here's the exact prompt I use in this lesson. This is what you'll run in Claude Desktop with the JetBrains MCP active:

```
In this folder, review:
- App - [Your App Name] - Market Research
- App - [Your App Name] - Summary
- App - [Your App Name] - Technical
- App - [Your App Name] - UX-UI
- The Figma user flow diagram we just created

When reviewed, using the JetBrains tool, write my specs and feature requirements for my 
product based on the user flows we just created.

Structure the specs by capability domain:
- Cover both happy paths and error cases
- Put it in my specs folder

Before you start:
1. Confirm you can find my project
2. List the capability domains you've identified from the flows
3. Ask me about any business rules or constraints that aren't obvious from the flows

Spec Quality Checklist:
- [ ] Scenarios are testable (specific inputs → specific outputs)
- [ ] Error cases are documented with expected behavior
- [ ] No implementation details in requirements (focus on WHAT, not HOW)
- [ ] Cross-references between related specs where needed

```

⚠️

Replace `[Your App Name]` with the actual name of your app as it appears in your Obsidian document titles. If your documents are named differently, update the prompt to match. Claude needs to find the actual files, it can't guess at naming.

### 3.3 What Happens When You Run It

The prompt is deliberately structured to make Claude do three things before it writes a single line:

**Step 1, Confirm it can find your project.** This sounds obvious, but it's important. If Claude can't see your project via the JetBrains tool, nothing else works. Making it confirm upfront saves you from running a long process only to find out mid-way that it was working in the wrong place.

**Step 2, List the capability domains.** This is a checkpoint for you. Before Claude writes anything, it tells you how it's planning to organise the specs. You can push back here. If it's identified domains that don't make sense for your product, or missed something important, this is where you correct it, not after it's written twenty spec files.

**Step 3, Ask about business rules.** This is where Claude flags the gaps. Things that aren't obvious from the documentation, pricing logic, permission levels, specific business rules that only you know. Claude surfaces these as questions rather than making assumptions. Answer them before you let it proceed.

Only after those three steps does Claude start writing the actual spec files into your `/specs` folder.

### 3.4 The Output Structure

When Claude is done, your project folder should look something like this:

```
/[your-project]/
  /specs/
    authentication.md
    onboarding.md
    [domain-name].md
    [domain-name].md
    ...

```

Each file covers one capability domain, with happy paths and error cases for every scenario within that domain. The filenames are lowercase, hyphenated, and descriptive enough that you know exactly what's inside without opening them.

---

## 4\. Try It Yourself

### Running the Spec Prompt

Here's how to run this yourself:

1. Open Claude Desktop with your JetBrains MCP connection active
2. Make sure WebStorm is open and your project is loaded
3. Paste the prompt from Section 3.2, updated with your app name
4. Wait for Claude to complete Steps 1,3 before it starts writing
5. Review the capability domains it proposes and correct anything that's off
6. Answer any business rule questions it raises
7. Let it proceed and write the spec files

**What success looks like:** A `/specs` folder in your project containing individual `.md` files for each capability domain. When you open one, it should read like a clear, testable description of what the product needs to do, not technical jargon, not vague intentions.

**Now try this:** Pick one spec file Claude generated and run it against the quality checklist in Section 2.3\. Does each scenario have a specific, verifiable outcome? Are the error cases covered? If not, ask Claude to revise that specific spec file before moving on.

---

## 5\. Watch Out For These

⚠️

****Claude writes specs that are too vague to test**  
Here's why this happens: if the source documents (UX/UI doc, user flow) are themselves vague, Claude has no concrete inputs to work from and will fill in the gaps with generalities.  
The way I avoid it: before running this prompt, review your UX/UI document and user flow. Are the flows specific? Do they show specific screens and states? The more specific your inputs, the more testable your outputs.  
If you've already hit this: ask Claude to revise each vague scenario, "rewrite this scenario with specific inputs and measurable outputs."

⚠️

****Claude can't find one of the source documents**  
Here's why this happens: the document names in the prompt don't match exactly what's in your Obsidian vault.  
The way I avoid it: check your Obsidian document titles before running the prompt and make sure the names match exactly.  
If you've already hit this: ask Claude which document it couldn't find, check the actual filename in Obsidian, and update the prompt to match.

⚠️

****Implementation details are creeping into the specs**  
Here's why this happens: Claude has a tendency to suggest implementation approaches, especially when the technical document is detailed. It's trying to be helpful, but specs shouldn't dictate how something is built.  
The way I avoid it: if you see anything in a spec that sounds like "the system will use a PostgreSQL table to store...", that's implementation detail. Ask Claude to rewrite those sections focusing on behaviour only.

🚨

****Claude skips the three pre-flight steps and goes straight to writing**  
Here's why this happens: occasionally Claude will interpret the prompt as a single instruction and jump straight to generating files.  
The way I avoid it: if it does this, stop it. Ask it to go back and confirm the project location and list the capability domains first. The pre-flight check isn't just housekeeping, it's how you catch problems before they're baked into twenty files.

---

## 6\. Practice

### Exercise 1: Run the Full Prompt

**What to do:** Run the spec prompt against your own project documentation. Let Claude complete all three pre-flight steps, review the proposed capability domains, answer its questions, and let it generate the spec files.

**A nudge if you're stuck:** If Claude asks you a business rule question and you're not sure of the answer, that's actually useful information, it means the requirement wasn't clear in your documentation. Take a moment to think it through before answering. The spec is only as good as the decisions you've made.

**How you'll know it's working:** Your WebStorm project has a `/specs` folder. Inside it, there are individual `.md` files for each capability domain. Each file contains scenarios with specific inputs and outputs.

### Exercise 2: Audit One Spec File

**What to do:** Pick the capability domain that matters most to your product (probably authentication or onboarding, the first things a user encounters). Open that spec file and go through it line by line against the quality checklist in Section 2.3.

**What this is practising:** Critical reading of specs. This is the skill you'll use constantly in Module 4, checking what Claude built against what the spec says it should do.

---

## 7\. You Should Be Able to Build This Now

Here's what you can do with what we just covered:

- Take any set of product documentation (research, UX docs, user flows) and generate a structured spec folder using Claude
- Organise requirements by capability domain rather than by screen
- Use the pre-flight confirmation pattern in other Claude prompts, confirm → propose structure → ask questions → execute

### Check Yourself

- I've run the spec prompt and Claude confirmed it could find my project
- I reviewed the proposed capability domains and they make sense for my product
- My `/specs` folder exists in the project and contains individual spec files
- I've run at least one spec file against the quality checklist and it passes

✅

If those boxes are ticked, you've done something most people skip entirely and then pay for later. You've got a proper spec. That's the foundation for everything in Module 4\. Nice work.

### If Something's Not Working

⚠️

****Claude created the specs but the /specs folder isn't showing up in WebStorm**  
****What's happening:** WebStorm might need a moment to pick up new files added via MCP. Or Claude wrote the files to a slightly different path than expected.  
****How to fix it:** Right-click the project root in the WebStorm sidebar and click "Reload from Disk" (or the equivalent in your OS). If the folder still isn't there, ask Claude "where did you save the spec files?", it'll tell you the exact path.

---

## The Short Version

Here's what I want you to walk away with:

- **Specs live in the codebase, not in a separate doc tool**: this keeps them in sync with what gets built and makes them accessible to Claude during development.
- **Organise by capability domain**: not by screen, not by feature name. What does the product need to *do*? Let that shape the structure.
- **The pre-flight check matters**: making Claude confirm, propose, and ask before it writes is how you catch problems early rather than unwinding twenty files later.
- **Use the quality checklist**: testable scenarios, documented error cases, no implementation details, cross-references where needed. If a spec doesn't pass, it's not done.
- **What you can do now:** You have a structured spec folder in your project. Module 4 coding starts here.

---

## Quick Reference

### The Spec Prompt (ready to customise)

```
In this folder, review:
- App - [Your App Name] - Market Research
- App - [Your App Name] - Summary
- App - [Your App Name] - Technical
- App - [Your App Name] - UX-UI
- The Figma user flow diagram we just created

When reviewed, using the JetBrains tool, write my specs and feature requirements for my 
product based on the user flows we just created.

Structure the specs by capability domain:
- Cover both happy paths and error cases
- Put it in my specs folder

Before you start:
1. Confirm you can find my project
2. List the capability domains you've identified from the flows
3. Ask me about any business rules or constraints that aren't obvious from the flows

Spec Quality Checklist:
- [ ] Scenarios are testable (specific inputs → specific outputs)
- [ ] Error cases are documented with expected behavior
- [ ] No implementation details in requirements (focus on WHAT, not HOW)
- [ ] Cross-references between related specs where needed

```

### Spec Quality Checklist

```
✓ Scenarios are testable — specific inputs → specific, verifiable outputs
✓ Error cases are documented with expected behaviour
✓ No implementation details — WHAT, not HOW
✓ Cross-references between related specs where needed

```

### Expected Output Structure

```
/[your-project]/
  /specs/
    [capability-domain].md
    [capability-domain].md
    [capability-domain].md
    ...

```

---

## Resources

### Tools Used

- [Claude Desktop](https://claude.ai/download?ref=deletosh.com)
- [WebStorm by JetBrains](https://www.jetbrains.com/webstorm/?ref=deletosh.com)
- [Obsidian](https://obsidian.md/?ref=deletosh.com)where your source documents live

---

## Questions I Get Asked

**Q: Can I run this prompt before I've finished the Figma user flow?**

You can, but I wouldn't. The user flow is the most specific piece of the puzzle, it shows Claude exactly how users move through the product, what states they encounter, what decisions they make. Without it, the specs will be more generic. Finish the flow first, then come back to this.

**Q: How many capability domains should I expect?**

It depends on the product, but for most early-stage products I'd expect somewhere between five and ten. If Claude is proposing twenty-plus domains, the prompt might be generating specs at too granular a level, push back and ask it to consolidate.

**Q: Do I need to review every spec file before we move to Module 4?**

You don't need to read every word of every file, but you should at least open each one and check that it looks sensible. The goal isn't perfection, it's catching any obvious gaps or misunderstandings before you start building against them.

**Q: How do I know I'm ready for the next lesson?**

If your `/specs` folder exists, has files that make sense for your product, and at least your core domains pass the quality checklist, you're ready.

---

## 💬 Stuck? Come Talk to Us

💡

If something's not clicking or you want to share what you've built, come find us in Discord.  
****Build What Ships community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community's active and I check in there too.

---

## Glossary

**Feature Spec (Feature Requirement):** A document that describes what a specific part of the product needs to do, specific inputs, expected outputs, and error cases, without specifying how it's built. Specs are the contract between product intent and development. *(first introduced in Module 3, Lesson 2)*

**Capability Domain:** A logical grouping of related product behaviours. Rather than organising specs by screen or feature name, capability domains group by what the product *does*e.g. Authentication, Onboarding, Notifications. *(first introduced in Module 3, Lesson 2)*

**Happy Path:** The scenario where everything works as expected, the user does the right thing, the system responds correctly. Specs always cover the happy path first. *(first introduced in Module 3, Lesson 2)*

**Error Case:** What happens when the happy path breaks, missing input, network failure, duplicate data, unexpected user behaviour. A spec without documented error cases is incomplete. *(first introduced in Module 3, Lesson 2)*

**Pre-flight Check:** The pattern of asking Claude to confirm, propose, and ask questions *before* it executes a long task. Introduced in this lesson as part of the spec prompt, Claude confirms the project, lists the domains, asks about business rules, then proceeds. *(first introduced in Module 3, Lesson 2)*
### Module 3, Lesson 1: Setting Up WebStorm + Claude
URL: https://deletosh.com/courses/product-path/03-01-setup-webstorm-claude/
Last updated: 2026-07-16T15:33:35.000Z
**How do you set up WebStorm and connect it to Claude?** You install WebStorm, create your project, then enable MCP and wire it to Claude Desktop.

Now Claude can control your editor and write straight into the codebase. It turns your Module 2 docs into a real build environment.

## What is MCP and why connect WebStorm to Claude Desktop?

MCP (Model Context Protocol) is the integration layer that lets Claude Desktop read and act inside other tools, the same way it connected to Obsidian and Figma earlier in the course.

Connecting WebStorm to Claude Desktop over MCP means Claude can control your editor and write code directly into your project instead of you copying and pasting. In this lesson you install WebStorm, create a project, enable MCP, and verify the connection so your coding sandbox is ready for the rest of Module 3.

If you've been following along, you should have a solid stack of documentation by now, research summary, PRD, GTM, UX docs, and a user flow diagram. That's everything we built in Module 2.

Now we're moving into Module 3\. This is where things get a bit more hands-on, we're about to start connecting Claude to your actual coding environment. In this lesson, I'm getting WebStorm installed, a project created, and Claude Desktop wired in via MCP so we can start writing specs directly into the codebase.

ℹ️

No corrections or updates to previous lessons before we dive in.

---

## Before We Start

Here's what I'd expect you to have under your belt before this lesson:

**From previous lessons:**

- You should be comfortable using Claude Desktop, we've been living in it since Module 1
- You should understand what MCP is and what it does, we covered the concept in Module 2 when we connected Claude to Obsidian and Figma
- Your documentation from Module 2 should be complete: research summary, PRD, GTM, UX docs, and user flow

**Tools / setup you'll need:**

- WebStorm installed (free download from JetBrains.com, it will ask about a licence, but you can use the free trial or their free tier)
- Claude Desktop already installed and running
- VS Code is a perfectly valid alternative to WebStorm if that's what you prefer, everything I do here maps across

**By the end of this lesson, you'll:**

- Have a new WebStorm project created and know where it lives on your machine
- Have MCP enabled in WebStorm and connected to Claude Desktop
- Be able to verify the connection works, Claude controlling your editor is a genuinely exciting moment

---

## About This Lesson

**Duration:** \~10 minutes video + \~15 minutes setup  
**Skill Level:** Intermediate  
**What You'll Build:** A WebStorm project connected to Claude Desktop via MCP, your coding sandbox, ready for everything in Module 3 and beyond.

I'll be honest with you, this lesson is a bit of a departure from what we've been doing. Most of Module 2 was research and documentation, which is fairly low-friction. This is setup, and setup can be finicky. I'm going to slow things down and walk through every step. If something doesn't go exactly as it does for me, don't panic, come find us in Discord and we'll sort it out. The payoff is real.

---

## Watch the Lesson

---

ℹ️

****How I'd suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section, pausing the video at the timestamps I've noted. After that, this guide is your reference, you shouldn't need to rewatch to look something up.

---

## What We're Covering

Here's what I'm walking you through in this lesson:

- **What WebStorm is and why I use it**: your coding sandbox and what role it plays from here on
- **Creating your first project**: the setup steps and why the project path matters
- **Enabling MCP in WebStorm**: flipping the switch that lets Claude control your editor
- **Connecting Claude Desktop to WebStorm**: the auto-configure flow and what it does
- **Testing the connection**: the quick sanity check that proves it's all working

---

## 1\. Let's Set the Scene *(\~0:00)*

So far in this course, I've introduced you to a few tools. We've used Claude as the engine for everything, research, documentation, user flows. We used Obsidian to capture notes, and Figma to map the user journey visually. And if you've been keeping up, you should have a lot of that documentation all done by now.

In this module, we're moving into something a little different: building. And before we can do that, I need to introduce you to WebStorm.

WebStorm is a code editor, it's the tool I use to write and manage code. Think of it as the sandbox where the actual project lives. We're going to connect it to Claude Desktop using MCP, the same integration we used with Obsidian and Figma in Module 2\. Except this time, Claude's not writing notes or diagrams, it's going to be writing code directly into your project.

I want to be upfront: this lesson is a step up in difficulty from what we've done so far. I'd say it's still very manageable, but it's the kind of thing where if you rush, you'll trip. Take it slow, follow every step, and if something doesn't go right, that's what the community is for.

⚠️

If you're not planning to build the app yourself, if you're going to hand this off to someone else to build, you can actually skip this module and jump straight to the sales and marketing section. But if you want to build it yourself, which I'm assuming you do, stay with me here.

---

## 2\. The Core Idea

### 2.1 What WebStorm Is (and Why It Matters)

WebStorm is a code editor made by JetBrains. It's the tool I personally use to write, organise, and review code. You've probably heard of VS Code, WebStorm is in the same family. It's where your project folder lives, where you browse files, and where you'll eventually review what Claude writes.

I prefer WebStorm. But honestly, if you're already comfortable with VS Code, use VS Code, the MCP integration works the same way. I'm not going to pretend there's a huge functional difference. I just like how JetBrains tools work, so that's what you'll see me using.

### 2.2 What MCP Is Doing Here

We first talked about MCP back in Module 2 when Claude started writing directly into Obsidian. The same principle applies here: MCP is a protocol that lets Claude control other applications. When we enable MCP in WebStorm and connect it to Claude Desktop, we're essentially giving Claude a set of tools it can use to read and write files in your project.

This is a big deal. Instead of copying and pasting code back and forth between Claude and your editor, Claude will be able to reach directly into your project folder. It knows what files exist, can read them, and can write to them. That's what makes this setup feel genuinely powerful rather than just another chatbot.

ℹ️

Think of it this way: before MCP, using Claude for coding was like having someone very smart in the room who couldn't see your screen. After MCP, they can see your screen and type on your keyboard. That's the shift.

---

## 3\. Let Me Show You How It Works *(\~1:48)*

### 3.1 Step 1: Download and Install WebStorm

Head to [jetbrains.com/webstorm](https://www.jetbrains.com/webstorm/?ref=deletosh.com) and download it. Install it the normal way for your OS (Mac or Windows). Once it's installed, open it up.

💡

WebStorm isn't free forever, but JetBrains offers a free trial and there's also an option for non-commercial use. If you're building a side project, check what applies to your situation. VS Code is always free if you'd rather not deal with licencing at all.

### 3.2 Step 2: Create a New Project

When WebStorm opens, you'll see an option to create a new project. Click it.

WebStorm will ask you where to save the project. It'll give you a default path, something like `/Users/yourname/WebstormProjects/untitled`. **Take note of this path.** You're going to need it.

Here's what I do: I copy the project path and paste it somewhere I can find it later, I drop it in an Obsidian note. It sounds like a small thing, but we'll reference this path when setting things up with Claude, and you don't want to be hunting for it.

**Give the project a name.** Mine is called `notural` because that's the app I'm building. Use whatever makes sense for your project.

A couple of things worth knowing about this step:

- WebStorm will ask if this is a JavaScript or TypeScript project. Don't worry about it for now, it doesn't really matter at this stage.
- You'll see a **"Create Git repository"** checkbox. I'm leaving that unchecked for now. We'll deal with Git later when it matters.

Click **Create**.

### 3.3 Step 3: Enable MCP in WebStorm

This is the key step.

Once your project is open, go to **Preferences** (on Mac: click the app name in the menu bar → Preferences; on Windows: look for Settings in the app menu).

In the Preferences/Settings window, type **MCP** in the search box. You'll see **MCP Server** come up. Click on it.

By default, MCP is probably disabled. You want to enable it. Check the box.

Once it's enabled, you'll see an option to look for the **Claude app** and click **Auto-configure**. Do that. WebStorm will find your Claude Desktop installation and set everything up automatically. It may ask you to reopen Claude Desktop, do that too.

⚠️

If you don't see a Claude entry after enabling MCP, use the Auto-configure button. It handles the connection for you. If it still doesn't appear, quit Claude Desktop completely and reopen it, that usually resolves it.

Click **OK** to close Preferences.

### 3.4 Step 4: Restart Claude Desktop

Once you've saved the MCP settings in WebStorm, **fully quit Claude Desktop** (don't just close the window, actually quit it) and reopen it. This ensures Claude picks up the new MCP connection to WebStorm.

### 3.5 Step 5: Test the Connection

Here's the moment of truth. With both WebStorm open and Claude Desktop running, go into a new Claude chat and type something like:

```
Using the JetBrains tool, show me the list of files in my project.

```

If everything is wired up correctly, Claude will use the JetBrains MCP tool, identify your project automatically, and return a list of the files and folders inside it, without you having to tell it where anything is.

When that happens, you're done. Claude can now see and control your coding environment.

✅

What you're looking for: Claude returns a list of files that matches what you see in the WebStorm sidebar. If it matches, the connection is live.

---

## 4\. Try It Yourself

### Verify the Setup

Once you've got everything connected, test it with this prompt in Claude Desktop:

```
Using the JetBrains tool, show me the list of files in my project.

```

**What success looks like:** Claude responds with a list of files that matches what you see in your WebStorm sidebar. The project name and file structure should match exactly.

**Now try this:** Ask Claude something slightly more specific, like "show me the contents of the first file in my project." If it can read file contents, the integration is fully working.

---

## 5\. Watch Out For These

⚠️

****Claude doesn't see your project**  
Here's why this happens: Claude Desktop wasn't restarted after enabling MCP in WebStorm, so it never picked up the new connection.  
The way I avoid it: always fully quit and reopen Claude Desktop after making MCP changes in WebStorm.  
If you've already hit this: quit Claude completely, reopen it, then try the test prompt again.

⚠️

****Auto-configure doesn't find Claude**  
Here's why this happens: Claude Desktop might not be running when WebStorm tries to detect it.  
The way I avoid it: make sure Claude Desktop is open before you go into WebStorm's MCP settings.  
If you've already hit this: open Claude, go back to WebStorm Preferences → MCP, and try Auto-configure again.

⚠️

****Not sure where your project was saved**  
Here's why this happens: the default WebStorm project path can be easy to miss if you click through quickly.  
The way I avoid it: I always copy the project path into an Obsidian note the moment I create the project. Takes five seconds and saves a lot of hunting later.

---

## 6\. Practice

### Exercise 1: Get the Basics Down

**What to do:** Complete the full setup, install WebStorm, create your project, enable MCP, connect Claude, and run the test prompt.

**A nudge if you're stuck:** The most common failure point is forgetting to restart Claude Desktop after enabling MCP. If the test prompt doesn't work, that's the first thing to check.

**How you'll know it's working:** Claude returns a file list that matches your WebStorm sidebar exactly.

### Exercise 2: Push It Further

**What to do:** Once the connection is verified, ask Claude to describe the structure of your project, something like "using the JetBrains tool, describe my project structure." See how much it can infer about what you're building just from the folder and file layout.

**What this is practising:** Getting comfortable with the idea of Claude as something that understands your project, not just a chat window.

---

## 7\. You Should Be Able to Build This Now

Here's what you can do with what we just set up:

- Ask Claude to read any file in your project directly
- Have Claude start generating code that lands inside your actual project folder
- Use this setup as the foundation for everything in Module 3

### Check Yourself

- WebStorm is installed and I have a project created
- I know where my project is saved on my machine (and I've noted the path)
- MCP is enabled in WebStorm and Claude Desktop is connected
- I ran the test prompt and Claude returned the correct file list

✅

If you're ticking those boxes, you're ready for the next lesson. That's where we start writing specs directly into the project. Nice work getting this far.

### If Something's Not Working

⚠️

****The test prompt returns an error or Claude says it can't find the project**  
****What's happening:** The MCP connection between WebStorm and Claude Desktop isn't established yet.  
****How to fix it:** 1) Make sure WebStorm is open and your project is loaded. 2) Go to WebStorm Preferences → search MCP → confirm MCP Server is enabled and Claude appears in the list. 3) Fully quit Claude Desktop and reopen it. 4) Try the test prompt again.

---

## The Short Version

Here's what I want you to walk away with:

- **WebStorm is your coding sandbox**: it's where your project lives, and where you'll review and manage everything Claude builds.
- **MCP is what connects Claude to WebStorm**: once it's enabled, Claude isn't just chatting at you, it can actually see and write into your project.
- **Auto-configure does the heavy lifting**: you don't need to manually configure anything, just enable MCP and let it find Claude.
- **What you can do now:** Claude Desktop can read and write files in your WebStorm project. That's the foundation for everything we do from here.

---

## Quick Reference

### Setup Steps (in order)

```
1. Install WebStorm from jetbrains.com/webstorm
2. Create a new project — note the project path
3. WebStorm Preferences → search "MCP" → enable MCP Server
4. Click Auto-configure to connect Claude Desktop
5. Fully quit and reopen Claude Desktop
6. Test: ask Claude to list files in your project using the JetBrains tool

```

### Test Prompt

```
Using the JetBrains tool, show me the list of files in my project.

```

---

## Resources

### Links & Docs

- [JetBrains WebStorm](https://www.jetbrains.com/webstorm/?ref=deletosh.com)download and installation
- [VS Code](https://code.visualstudio.com/?ref=deletosh.com)free alternative if you prefer it

### Tools Used

- [WebStorm by JetBrains](https://www.jetbrains.com/webstorm/?ref=deletosh.com)
- [Claude Desktop](https://claude.ai/download?ref=deletosh.com)

---

## Questions I Get Asked

**Q: Do I have to use WebStorm, or can I use VS Code?**

VS Code works fine. Everything I'm doing with the JetBrains MCP has an equivalent in VS Code with its own MCP integration. I use WebStorm because it's what I'm comfortable with, but if you're already set up in VS Code and you don't want to switch, don't. The rest of the course follows the same logic regardless of which editor you're in.

**Q: My Auto-configure didn't find Claude, what do I do?**

Make sure Claude Desktop is actually running (not just installed) when you try Auto-configure. WebStorm needs to see Claude running to detect it. Open Claude, then go back into WebStorm Preferences → MCP and try again.

**Q: How do I know I'm ready for the next lesson?**

Honestly, if Claude can list your project files from the test prompt, you're good. That's the only thing that needs to be working before we move on.

---

## 💬 Stuck? Come Talk to Us

💡

If something's not clicking or you want to share what you've built, come find us in Discord.  
****Build What Ships community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community's active and I check in there too.

---

## Glossary

**WebStorm:** A code editor made by JetBrains. It's where your project folder lives, you browse files, review code, and run your app from here. Think of it as the physical desk where the building happens. *(first introduced in Module 3, Lesson 1)*

**MCP (Model Context Protocol):** The protocol that lets Claude control other applications, in this case, your coding editor. We first used MCP in Module 2 to connect Claude to Obsidian and Figma. Here we're using it to connect Claude to WebStorm. *(first introduced in* [*Module 2, Lesson 3*](https://deletosh.com/courses/the-product-path/02-03-generate-technical-document/) *\- Generating the Technical Document)*

**JetBrains:** The company that makes WebStorm (and a suite of other developer tools like IntelliJ, PyCharm, etc.). When Claude references the "JetBrains tool" in a prompt, it's referring to the MCP integration with WebStorm. *(first introduced in Module 3, Lesson 1)*

**Auto-configure:** The one-click option in WebStorm's MCP settings that automatically detects your Claude Desktop installation and sets up the connection. You don't need to manually configure anything, just click it. *(first introduced in Module 3, Lesson 1)*
### Module 2, Lesson 7: User Flow in Figma
URL: https://deletosh.com/courses/product-path/02-07-user-flow-in-figma/
Last updated: 2026-07-16T15:33:34.000Z
**How do you build a user flow diagram in Figma with Claude?** You hand Claude your four product docs, then connect Figma over MCP so Claude draws the whole flow in FigJam for you.

You never touch Figma yourself. You just need an account and a browser. This is also your first real use of MCP, walked through in The Product Path.

## What is a user flow diagram?

A user flow diagram is a visual map of how someone moves through your application, showing every step, every decision point, and every outcome, both the happy path and the edge cases.

If your PRD says what your app does, the user flow shows how someone actually experiences it, which is the difference between reading a description of a building and holding its floor plan. It typically traces from how a user first discovers the app through onboarding all the way to their first core action.

In this lesson, we're taking everything we've generated so far, the technical doc, the UX/UI overview, the stakeholder summary, the GTM, and turning it into something visual: a user flow diagram, built directly inside Figma using Claude and MCP.

ℹ️

This lesson also serves as your first proper introduction to MCP. We've touched on it in passing, but here you'll actually see it in action, Claude controlling an external app (Figma) on your behalf.

---

## Before We Start

**From previous lessons:**

- You should have all four documents ready: Technical Overview, UX/UI Overview, Stakeholder Summary, GTM Overview
- We've been building inside Claude's co-work feature, we'll continue working from there in this lesson

**Tools / setup you'll need:**

- Claude desktop app (not the browser, this matters, I'll explain why)
- A Figma account, free tier is fine, just go to figma.com and sign up
- Be logged into both Figma *and* Claude in your browser before you start
- The Figma connector installed in Claude (I'll walk through this)

**By the end of this lesson, you'll:**

- Understand what MCP is and why it matters for the way we work
- Know how to connect Figma to Claude using the connector (MCP integration)
- Have a complete user flow diagram in Figma, generated from your product documents
- Be able to interpret and iterate on that diagram before we move into the spec phase

---

## About This Lesson

**Duration:** \~6 minutes video + \~20 minutes setup and generation  
**Skill Level:** Beginner  
**What You'll Build:** A complete user flow diagram in Figma (FigJam), covering your app from first entry point to core user actions and edge cases

This lesson is a bridge. We've been in research and documentation mode, heads down, generating documents. Now we're going visual. The user flow diagram is how you take all those words and start to see how your product actually *works*how someone moves through it, what decisions they hit, where things can go wrong. It's one of those things that looks simple on the surface but does a lot of heavy lifting when you get into the build phase.

---

## Watch the Lesson

---

ℹ️

****How I'd suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section, pausing the video at the timestamps I've noted. After that, this guide is your reference, you shouldn't need to rewatch to look something up.

---

## What We're Covering

Here's what I'm walking through in this lesson and why it matters:

- **What a user flow diagram actually is**: not just theory, but what it's doing for you as someone building a product
- **Installing the Figma connector (MCP)**how to connect Claude to Figma so it can draw in there on your behalf
- **Running the prompt**: feeding your four documents into Claude and letting it generate the full flow
- **Reading and iterating the diagram**: what to look for, and how to keep prompting if something's missing

---

## 1\. Let's Set the Scene *(\~0:00)*

Before we jump into the next module, I want to make our user journey tangible, and introduce you properly to MCP, because we're going to be using it constantly from here on out.

Up to now, everything we've built has been text, documents living in Obsidian. That's great, but at some point you need to see the full picture. You need to see how a user actually moves through your app, from the moment they discover it to the moment they complete their first core action. That's what a user flow diagram gives you.

The tool professionals use for this is Figma. You don't need to know Figma, you genuinely don't. You just need an account and a browser. Claude is going to do the drawing. That's the whole point.

---

## 2\. The Core Ideas

### 2.1 What Is a User Flow Diagram?

A user flow diagram is a visual map of how someone moves through your application. It shows every step, every decision point, and every possible outcome, the happy path and the edge cases.

Think about it like this: your PRD says *what* your app does. Your user flow shows *how* someone actually experiences it. It's the difference between reading a description of a building and having a floor plan in your hands.

For my app, the flow starts with how someone finds it (the App Store, in my case), then traces through downloading, onboarding, entering their details, inviting other users, all the way to the first time they actually get value from the product. And it covers the edge cases too, like: what happens if they don't complete onboarding? What if they skip the invite step? Those branches matter, and you want to see them *before* you start writing code.

ℹ️

We're not designing the UI here. This has nothing to do with how the app looks, colours, fonts, buttons, none of that. This is purely about the logic of how someone moves through the product. UI design comes much later. Don't mix the two up.

### 2.2 What Is MCP?

MCP stands for Model Context Protocol. Here's how I think about it: connectors are like mini apps you can install inside Claude Desktop. Each connector gives Claude the ability to control a different external application, directly, from inside Claude, without you having to manually switch between tools.

The Figma connector is one of those. Once it's connected, Claude can open Figma, create a file, draw shapes, add labels, and build out a full diagram, all because you told it to in a prompt. You're not clicking around in Figma yourself. Claude is.

⚠️

This is why I keep saying you need the ****Claude desktop app**, not Claude in the browser. MCP connectors only work with the desktop version. If you're on claude.ai in a browser tab, you won't see the connectors option. Make sure you're on the app before you try to set this up.

### 2.3 How This Connects to What We've Been Building

Everything we've produced in Module 2 feeds into this lesson. The prompt I'm using asks Claude to review the Technical Overview, the UX/UI Overview, the Stakeholder Summary, and the GTM document, all four of them together, before drawing a single thing. That's intentional. The diagram should reflect the research, not just whatever Claude imagines your app might do. Grounding it in those documents is what makes it useful.

---

## 3\. Let Me Show You How It Works

### 3.1 Step 1: Set Up Your Figma Account

If you don't have one already, go to [figma.com](https://figma.com/?ref=deletosh.com) and create a free account. That's it. You don't need a paid plan for this.

Once you're in, just leave Figma open in your browser and make sure you're logged in. You don't need to create any files manually, Claude will handle that through the connector.

### 3.2 Step 2: Install the Figma Connector in Claude

Open the Claude desktop app. In the sidebar, go to **Settings**, then look for **Connectors**. You'll see a "Browse connectors" option, click that, and search for **Figma**.

💡

Think of connectors as the Claude equivalent of browser extensions, small add-ons that give Claude new abilities. The Figma connector specifically gives Claude the ability to create and edit diagrams in Figma directly. There are connectors for all kinds of tools, we'll be using more of them as the course goes on.

Click on the Figma connector and hit **Connect**. It'll redirect you to Figma to authenticate, just follow the flow, approve the connection, and you'll be brought back into Claude. Once you're back, the connector is live and Claude can talk to your Figma account.

### 3.3 Step 3: Run the Prompt in Co-Work

Go back into your co-work session in Claude, the same one where you've been generating documents. Paste in this prompt (it's also in the prompt library linked below):

```
Review the following documents: 
- Technical Overview
- UX/UI Overview
- Stakeholder Summary
- Sales & Marketing / GTM Overview

Using these as the foundation, I need you to create a comprehensive user flow diagram in Figma that maps:
1. User entry points (how users arrive)
2. Core user actions (the main jobs-to-be-done)
3. Decision points (where users make choices)
4. System responses (what happens after each action)
5. Error/edge cases (what can go wrong)
6. Success states (task completion points)

Use this color scheme for the flow:
- 🟦 Blue: User actions
- 🟩 Green: System processes  
- 🟨 Yellow: Decision points
- 🟥 Red: Error states
- ⬜ White: Start/End points

Before creating the diagram, if you're unclear, ask me clarifying questions about:
- The primary user persona
- The core user journey I want to map first
- Any existing flows or constraints I should know about
- Integration points with external systems

```

The key line in that prompt is the last part, *before creating the diagram, ask me clarifying questions*. Don't skip this. Claude will ask you things like: who's the primary user? What's the main flow you want to map first? Those answers shape the whole diagram, so take the time to respond properly.

### 3.4 What Happens Next

Once you've answered Claude's questions, it'll use the Figma connector to build the diagram directly in your Figma account. You'll see it appear in a new FigJam file.

The colour coding I've specified in the prompt makes the flow easy to read at a glance: blue shapes are things the user does, green shapes are things the system does in response, yellow is a decision point (yes/no, this path or that path), red is an error state, and white is the start or end of the flow.

---

## 4\. Reading the Diagram

Once it's generated, open it up in Figma. Hold **Alt and scroll** to zoom in and out, or use **+/-** on your keyboard to get a comfortable view.

Here's what you're looking for:

- Does it start where your users actually start? (App Store, web search, referral link, wherever they discover your product)
- Does it cover the core job-to-be-done, the main thing your user came here to do?
- Are the decision points represented? Every fork in the road should be visible
- Are the edge cases there? What happens if a user skips a step, or hits an error?

For my app, the flow runs from App Store discovery, through download and install, into email verification, then entering the kid's name, then inviting a parent, and then branches: if a parent accepts, one thing happens; if they don't, the app drops into solo mode. That branch, the solo mode fallback, is exactly the kind of thing you need to see before you build it, not after.

💡

You can share the Figma diagram with anyone, investors, a co-founder, a contractor, just by copying the share link. It's a surprisingly effective way to communicate what your app does without writing a word.

### If Something's Missing or Wrong

Don't stress about getting it perfect in one go. If you look at the diagram and something's off, a step is missing, a branch doesn't make sense, an edge case isn't covered, just come back to the prompt in Claude and tell it what to change. Something like:

> "The diagram doesn't show what happens when a user skips the invite step. Can you add that branch?"

Claude will go back into Figma via the connector and update it. That's the whole point of working this way, you're iterating, not starting over.

---

## 5\. Watch Out For These

⚠️

****Using Claude in the browser instead of the desktop app**  
This is the most common setup mistake. If you're on claude.ai in a browser tab, the Figma connector won't appear in settings. You need the desktop app. Download it from claude.ai/download if you haven't already.

⚠️

****Skipping Claude's clarifying questions**  
The prompt specifically asks Claude to ask you questions before drawing anything. If you skip past these or give vague answers, you'll get a generic diagram that doesn't reflect your product. Take a few minutes to answer properly, it makes a real difference to the output.

⚠️

****Confusing this with UI design**  
A user flow diagram is not a wireframe. It has no buttons, no colours for branding, no layout. If you find yourself thinking about what anything looks like visually, you've drifted into the wrong territory. Stay focused on: who does what, in what order, and what happens at each decision point.

---

## 6\. Practice

### Exercise 1: Generate Your Flow

Run the prompt above in your co-work session with your four documents in context. Answer Claude's clarifying questions carefully. Let it generate the diagram.

**How you'll know it's working:** A new FigJam file appears in your Figma account with a colour-coded diagram that maps at least one complete user journey end-to-end.

### Exercise 2: Find the Gap

Look at your diagram and find one thing that's missing, a decision point, an edge case, a step that's not represented. Then go back to Claude and prompt it to add that thing.

**What this is practising:** Getting comfortable with the iteration loop. The diagram isn't meant to be perfect on the first pass, the value is in the back-and-forth.

---

## 7\. You Should Be Able to Build This Now

Here's what you can do with what we've just covered:

- Generate a full user flow diagram for any product using your existing documentation
- Connect Claude to external tools via MCP connectors
- Iterate on a diagram without starting from scratch

### Check Yourself

- I've connected the Figma connector in Claude Desktop
- I've run the prompt with my four documents in context
- I have a user flow diagram in Figma that covers my app's core user journey
- I can zoom in and read the diagram clearly
- I've identified at least one thing to iterate on

✅

If you've got a diagram in Figma and you can follow the flow from entry point to a success state, you're done with Module 2\. The next module is where we start converting all of this into specifications and a build plan. Nice work getting here.

### If Something's Not Working

⚠️

****The Figma connector doesn't appear in Claude settings**  
****What's happening:** You're likely using Claude in a browser tab, not the desktop app.  
****How to fix it:** Download the Claude desktop app from claude.ai/download, log in, and look for connectors in the sidebar settings. The connector option only exists in the desktop version.

⚠️

****Claude generates the diagram but nothing appears in Figma**  
****What's happening:** The Figma connector may have lost authentication.  
****How to fix it:** Go back to Claude settings → Connectors → Figma, and reconnect. Then run the prompt again.

---

## The Short Version

Here's what I want you to walk away with:

- **User flow diagrams:** A visual map of how someone moves through your product, decisions, actions, edge cases, all of it. Not UI design. Logic.
- **MCP connectors:** Mini apps inside Claude Desktop that let Claude control external tools on your behalf. Figma is one. We'll use more.
- **What you can do now:** Turn your product documents into a visual user flow, share it with anyone, and iterate on it with a prompt.

---

## Quick Reference

### The Prompt

```
Review the following documents: 
- Technical Overview
- UX/UI Overview
- Stakeholder Summary
- Sales & Marketing / GTM Overview

Using these as the foundation, I need you to create a comprehensive user flow diagram in Figma that maps:
1. User entry points (how users arrive)
2. Core user actions (the main jobs-to-be-done)
3. Decision points (where users make choices)
4. System responses (what happens after each action)
5. Error/edge cases (what can go wrong)
6. Success states (task completion points)

Use this color scheme for the flow:
- 🟦 Blue: User actions
- 🟩 Green: System processes  
- 🟨 Yellow: Decision points
- 🟥 Red: Error states
- ⬜ White: Start/End points

Before creating the diagram, if you're unclear, ask me clarifying questions about:
- The primary user persona
- The core user journey I want to map first
- Any existing flows or constraints I should know about
- Integration points with external systems

```

### Color Coding Reference

| Color     | Meaning            |
| --------- | ------------------ |
| 🟦 Blue   | User actions       |
| 🟩 Green  | System processes   |
| 🟨 Yellow | Decision points    |
| 🟥 Red    | Error states       |
| ⬜ White   | Start / End points |

### Figma Navigation

```
Alt + Scroll       — zoom in/out
+ / -              — zoom in/out (keyboard)
Cmd/Ctrl + Shift + H — fit diagram to screen

```

---

## Resources

### Links & Docs

- [Figma, Sign Up](https://figma.com/?ref=deletosh.com)free account, all you need
- [Claude Desktop App](https://claude.ai/download?ref=deletosh.com)required for MCP connectors
- [Model Context Protocol, Anthropic Docs](https://docs.anthropic.com/en/docs/agents-and-tools/mcp?ref=deletosh.com)if you want to read more about how MCP works

### Tools Used

- [Figma](https://figma.com/?ref=deletosh.com)for the user flow diagram (FigJam)
- Claude Desktop, with Figma MCP connector enabled

---

## Questions I Get Asked

**Q: Do I need to know how to use Figma?**

Not at all. You literally don't touch Figma yourself in this lesson, Claude does the drawing. You just need an account and to be logged in. The most you'll do in Figma is zoom in to read the diagram.

**Q: Can I use a different diagramming tool instead of Figma?**

For this course, I'm using Figma because it has an MCP connector and because it's what professionals use. If you're already deep into another tool like Miro or Lucidchart, technically you could create the diagram there manually, but you'd lose the Claude integration. Figma is the path of least resistance here.

**Q: My diagram looks different from yours, is that a problem?**

No. The diagram should reflect your product, not mine. As long as it covers a complete user journey, entry point, core actions, decision points, edge cases, success states, it's doing its job. Yours will look different because your app is different.

**Q: How do I know I'm ready for the next lesson?**

If you've got a user flow diagram in Figma that maps your app's core journey from start to a success state, you're ready. Don't overthink it.

---

## 💬 Stuck? Come Talk to Us

💡

If something's not clicking or you want to share what you've built, come find us in Discord.  
****The Foundry community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community's active and I check in there too.

---

## Glossary

**User Flow Diagram:** A visual map showing how a user moves through an application, every action, decision, and outcome, from entry point to success state. Not a wireframe. Not a UI design. Pure logic. *(first came up in Module 2, Lesson 7)*

**MCP (Model Context Protocol):** The system that allows Claude to control external applications, like Figma, Obsidian, or YouTrack, directly from inside Claude Desktop. You give Claude a prompt; MCP is how it reaches out and does things in other tools on your behalf. *(first came up in Module 2, Lesson 7)*

**Connector:** An MCP integration you install inside Claude Desktop that gives Claude the ability to interact with a specific external tool. The Figma connector is what we use in this lesson. *(first came up in Module 2, Lesson 7)*

**Co-work:** Claude's collaborative working session feature, where your documents and context are maintained across the conversation. This is where we've been generating documents throughout Module 2\. *(introduced in* [*Module 2, Lesson 1*](https://deletosh.com/courses/the-product-path/02-01-market-research/)*)*

**FigJam:** Figma's whiteboard/diagramming mode. When Claude generates the user flow via the MCP connector, it creates it in FigJam format, which is ideal for flowcharts and visual mapping. *(first came up in Module 2, Lesson 7)*
### Prompt Library
URL: https://deletosh.com/courses/product-path/prompt-library/
Last updated: 2026-03-07T20:13:30.000Z
All Prompt organized

_This post is for subscribers only._
### Module 2, Lesson 6: Generating the GTM Document
URL: https://deletosh.com/courses/product-path/02-06-generate-gtm-doc/
Last updated: 2026-07-16T15:33:32.000Z
**How do you generate a go-to-market document with Claude?** You feed Claude the research and specs you already built, and it produces a concrete sales and marketing playbook: who you sell to, the channels that reach them, the message, and the launch order.

It is the bridge from having a product to actually selling it.

## What is a go-to-market (GTM) document?

A go-to-market document is your sales and marketing playbook for a product: the ideal customer, the channels you reach them through, the positioning and messages that land, and the sequence you launch in.

In this lesson you generate it with Claude from the market research, technical doc, UX/UI doc, and investor summary built earlier, so the plan is grounded in real evidence instead of guesswork.

In the last lesson, we produced the investor summary, the document you'd hand to someone considering putting money behind your idea. Now we're doing the final piece of this documentation phase. The go-to-market document. This is your sales and marketing playbook. It's the bridge between having a product and actually selling it.

ℹ️

No corrections or updates to previous lessons at this point. We're closing out Module 2 clean.

---

## Before We Start

Here's what I'd expect you to have in place:

**From previous lessons:**

- All five documents from Module 2 so far, market research, technical doc, UX/UI doc, and investor summary, saved in your project folder
- Claude Desktop open, with Cowork pointed at your project folder
- Your ideal customer profile (ICP) is implicit in your research doc, Claude will pull from it

**Tools / setup you'll need:**

- Claude Desktop (local desktop app, not the browser version)
- Obsidian (or whichever notes tool you're using) with your project folder accessible
- The GTM prompt, it's in Section 3.1 of these notes. Fill in `{{product_name}}`, `{{domain}}`, `{{marketing_budget}}`, and `{{team_size}}` before running it.

**By the end of this lesson, you'll:**

- Have a complete go-to-market document saved to your project folder
- Know which channels actually make sense for your product at this stage (and which ones to ignore)
- Understand how Claude uses your earlier documents as grounding to produce a strategy rooted in real data
- Have everything you need to move into Module 3, spec, plan, and build

---

## About This Lesson

**Duration:** \~8 minutes video + \~20 minutes practice  
**Skill Level:** Intermediate  
**What You'll Build:** A go-to-market strategy document, your sales and marketing playbook

This is the last document we're generating before moving into the spec-and-plan phase. I want to be honest with you: building is the part everyone gets excited about. But selling? That's the hard part. Everyone can build now, especially with tools like Claude. What separates the products that ship and grow from the ones that die quietly is whether you actually have a plan to reach people. This lesson is about making sure you've got that written down before you write a single line of code.

---

## Watch the Lesson

Embedded iFrame

---

ℹ️

****How I'd suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section. After that, this is your reference. You shouldn't need to rewatch to look something up.

---

## What We're Covering

Here's what I'm walking you through in this lesson:

- **Why a GTM document matters**: and why "I'll figure out marketing later" is the fastest way to ship something nobody finds
- **Running the GTM prompt in Cowork**: same workflow as the previous docs, with some key things to pay attention to
- **What Claude produces**: walking through the actual output so you know how to read and use it
- **The full Module 2 recap**: everything we've built across this documentation phase, and how it all connects forward

---

## 1\. Let's Set the Scene *(\~0:00)*

This is the final document for the documentation phase. And it's the one that makes everything else come alive.

You can do all the market research in the world. You can build a technically solid product with a beautifully documented UX. But if you haven't thought through how you're actually going to reach the people who'll pay for it, you're building in a vacuum. That's what the go-to-market document is for. It's your sales and marketing playbook, a written strategy for how you take what you've built out to the people who need it.

The reason I always do this *before* we start building is simple: your GTM strategy should influence how you build. If you know your growth is going to come from product-led virality rather than paid ads, that changes what features you prioritise. If you know your primary channel is Apple Search Ads, that shapes your onboarding. Building without this document is guessing.

---

## 2\. The Core Idea

### 2.1 What a GTM Document Actually Is

A go-to-market document is your sales and marketing playbook. It answers the questions that a lot of founders don't actually sit down and write out:

- Who exactly are we going after first?
- How are we going to reach them?
- What are we *not* going to do (and why)?
- What does success look like in year one?
- What's our realistic budget for this?

It's not a brand deck. It's not a social media content calendar. It's a strategic document, grounded in your market research and your ideal customer profile, that gives you and anyone working with you clarity on the game plan.

### 2.2 How This Connects to the Rest of Module 2

This is why we do things in order. The GTM document pulls from everything we've built in this module:

- The **market research** gives Claude the competitive landscape and demand signals
- The **technical document** tells Claude what we're building and how it works
- The **UX/UI document** informs how the product experience maps to the customer journey
- The **investor summary** established who our ideal customer is and what the financial picture looks like

Claude uses all of that as context. This is the beauty of the sequential approach, by the time we get here, the document practically writes itself because the research is already done. We're not making things up. We're synthesising.

ℹ️

This is exactly what I mean when I say "one thing after the other." We're not jumping the gun. Each document feeds the next. By lesson six, the GTM prompt has five solid documents to work with, and the output quality reflects that.

---

## 3\. Let Me Show You How It Works *(\~0:30)*

### 3.1 The Prompt

Here's the full prompt. Fill in the four placeholders before running: `{{product_name}}` (your app name), `{{domain}}` (your validated domain, e.g. `nurturo.app`), `{{marketing_budget}}` (your monthly marketing & sales budget, e.g. `$500`), and `{{team_size}}` (e.g. `solo founder` or `founder + 1 part-time`). Everything else copies as-is.

💡

Before you run this, check that Cowork is correctly pointed at your project folder. Claude needs access to all five previous documents, especially the market research and investor summary, to produce a grounded GTM strategy. If it doesn't have them, the output will be generic.

```markdown
You are a growth strategist specialising in products for solopreneurs and lean teams.

You will find the market research and product documents in the folder.

Your job is to produce a comprehensive Sales, Marketing & Go-To-Market Plan document in Markdown — the kind a founder and a small team can execute against week-by-week with a limited budget.

Output filename: App - {{product_name}} - GTM.md

Product domain: {{domain}}

---

## Input

You will receive:

1. A market research report (in the folder) — primary source for understanding what the product does, who it serves, its pricing, competitive landscape, and any technical notes.
2. A technical document (in the folder) — reference for the build approach and platform.
3. A UX/UI document (in the folder) — reference for how the product experience maps to the customer journey.
4. An investor/stakeholder summary (in the folder) — reference for the ICP, revenue model, and milestone structure.
5. Product name — it is in the file names.
6. Product description — defer to the market research. Do not ask.

---

## Constraints

- Budget: ~{{marketing_budget}} total marketing & sales spend per month
- Team: {{team_size}}
- Timeline: Aligned with the investor summary's milestone structure
- Depth: Strategy and plan level — describe what to do, why, and when. Do not write ready-to-send copy, full email templates, or complete ad creatives. Reference formats and examples where helpful, but keep them illustrative (1–2 sentences max).

---

## Document Structure

Follow this structure precisely. Every section is required unless marked (if applicable).

### Header

# {{product_name}} — Sales, Marketing & GTM Plan
### Domain: {{domain}}

Open with a 2–3 sentence executive summary: who the target buyer is, what the primary GTM motion will be, and the revenue goal this plan is designed to hit.

### 1. GTM Strategy Overview

Primary Motion: One paragraph identifying the lead GTM motion (e.g. founder-led outbound, product-led growth, community-led, content/SEO, partnerships). Choose based on what the research reveals about how the target customer discovers and buys software. Justify the choice in 2–3 sentences citing research findings.

Secondary Motions: A bulleted list of 2–3 supporting channels with 1-sentence rationale each.

What We're NOT Doing (and Why): A bulleted list of 2–3 channels explicitly excluded, with 1-sentence reasoning. This prevents scope creep and shows strategic discipline.

### 2. Ideal Customer Profile (Sales Lens)

Go deeper than the investor summary's ICP. This section is for targeting and outreach:

- Firmographics: Practice size, revenue range, geography, relevant categories
- Technographics: Current tools they use, signals of tech readiness
- Behavioral Signals: What they're doing that indicates they're ready to buy (e.g. posting about a pain point, recently hired, growing workload)
- Where They Congregate: 5–8 specific online and offline places — name actual subreddits, LinkedIn groups, conferences, Slack communities, forums, Facebook groups, podcasts. Verify these exist and are active.
- Disqualifiers: 3–4 signals that someone is NOT a fit

### 3. Positioning & Messaging

One-Liner: A single sentence that works in a cold email subject, a LinkedIn headline, and a homepage hero.

Positioning Statement: "For [target], who [pain], [product] is a [category] that [key benefit]. Unlike [competitor], we [differentiator]."

Core Messages by Audience Segment: A table with columns: Segment, Primary Pain, Core Message, Proof Point. Include 2–3 segments.

Objection Map: A table with columns: Objection, Response, Evidence. Include 5–7 common objections the research surfaces or implies. Responses should be specific, not generic.

### 4. Channel Strategy

For each active channel, provide:

- Channel name
- Goal (awareness, leads, conversion, retention — pick one primary)
- Tactics — 3–5 specific actions, not vague strategies
- Cadence — How often (daily, 3x/week, weekly, etc.)
- Tools — Specific tools to use with estimated cost
- Success Metric — One measurable KPI
- Budget Allocation — Dollar amount from the {{marketing_budget}}/mo budget

Typical channels to evaluate (include only those that made the cut from Section 1):

- Cold Email Outreach
- LinkedIn (organic + outreach)
- Content Marketing / SEO
- Twitter/X (building in public)
- Reddit / Community Engagement
- Paid Ads (Google, LinkedIn, Meta, App Store)
- Partnerships / Integrations
- Referral Program
- Product-Led Growth Mechanics

End with a Monthly Budget Summary Table — columns: Channel, Monthly Spend, Primary Tool.

### 5. Sales Process

Sales Model: One paragraph describing the sales motion (self-serve, demo-first, hybrid). Justify based on price point and buyer behavior from the research.

Pipeline Stages: A table with columns: Stage, Definition, Actions, Exit Criteria. Include 5–7 stages from Lead to Closed Won.

Lead Scoring (Simple): A table with columns: Signal, Points, Source. Include 8–10 signals. Keep the scoring model simple enough for a founder to run manually or with basic CRM automation.

Follow-Up Cadence: A table showing the outreach sequence — columns: Day, Channel, Action, Goal. Cover Days 1–30 of a typical lead lifecycle.

### 6. Content Strategy

Content Pillars: 3–4 thematic pillars with 1-sentence descriptions, grounded in the pain points the research identifies.

Content Types by Funnel Stage: A table with columns: Stage (TOFU/MOFU/BOFU), Content Type, Topic Examples (2–3 each), Distribution Channel.

Publishing Cadence: A table with columns: Content Type, Frequency, Owner, Distribution. Be realistic for a small team.

SEO Keywords (Starter Set): A table with 10–15 keywords — columns: Keyword, Intent (informational/commercial/transactional), Estimated Difficulty (Low/Medium/High), Priority. Research these based on the product's domain — assess intent and competition level; do not guess.

### 7. Launch Plan

A week-by-week plan for Weeks 1–4 (pre-launch and launch). Each week should have:

- Week number and theme (e.g. "Week 1: Foundation")
- 5–7 specific tasks as a checklist
- Focus on actions that generate pipeline, not just setup

### 8. Growth Milestones

Align with the investor summary's milestone structure. For each milestone:

- Revenue Target (MRR or total revenue)
- Customer Target (count)
- Pipeline Target (leads, demos, trials)
- Channel Targets (followers, email list size, content published)
- Key Action — The single most important thing to do in this phase

### 9. Metrics & Reporting

North Star Metric: One metric that best captures product-market fit progress.

Dashboard Metrics: A table with columns: Metric, Target, Frequency, Tool. Include 8–12 metrics across categories: Acquisition, Activation, Revenue, Retention.

Weekly Review Checklist: A bulleted list of 5–7 things to review every Monday morning.

### 10. Risks & Contingencies

A table with columns: Risk, Likelihood (High/Medium/Low), Impact (High/Medium/Low), Contingency. Include 5–7 risks specific to the GTM plan — not general business risks (those belong in the investor summary). Examples: "Cold email domain gets flagged", "Primary keyword has no search volume", "Primary channel restricts account."

---

## Research & Gap-Filling

- Mine the research report for every GTM-relevant insight: where the target customer hangs out, how they discover tools, what competitors' GTM strategies are, pricing sensitivity, and switching costs.
- Reference the investor summary for ICP, milestone structure, and revenue targets — the GTM document must align with those.
- Search the web for: current pricing of outreach tools (e.g. Instantly, Apollo, Smartlead, Lemlist), ad platform minimum spends, community/forum activity levels for the target audience, and any competitor GTM moves visible online.
- Name specific tools with current pricing — the budget table must be grounded in reality.
- Research real communities — verify that subreddits exist, LinkedIn groups are active, conferences are current-year.

---

## Quality Standards

- Actionable over aspirational. Every section should answer "What do I do Monday morning?" not "What would be nice."
- Budget-aware. Every recommendation must fit within the {{marketing_budget}}/mo constraint. If a channel requires significantly more to be effective, say so and explain why it's excluded.
- Specific over generic. "Post 3x/week on LinkedIn about [topic pillar]" beats "Be active on social media." "Use Instantly ($30/mo) for cold email with 3 sending accounts" beats "Do email outreach."
- Founder-realistic. This plan should be executable by one person dedicating 10–15 hours/week to sales and marketing. If it requires more time, flag it and suggest what to cut.
- Aligned with the investor summary. Revenue targets, timelines, and ICP should be consistent with the Product Summary document.
- Target length: 300–450 lines of Markdown.

```

### 3.2 Understanding the Prompt

A few notes on the key sections and placeholders.

**Five documents as input**This prompt has more context than any of the previous ones. By the time you run it, Claude has your market research, technical doc, UX/UI doc, and investor summary all in scope. That's why the GTM document tends to be the most specific and actionable of the batch, it's synthesising everything that came before it. If you've started a fresh Cowork session, that context is lost and the output will be noticeably more generic.

**{{marketing\_budget}}**This is your monthly marketing and sales spend, not your infrastructure budget. They're different numbers. Set this to whatever you can realistically spend on reaching customers, it shapes every channel recommendation and every budget allocation in Sections 4 and 9.

**{{team\_size}}**Affects the realism of the execution plan. "Solo founder" produces a very different content cadence and channel depth than "founder + 2 part-time." Be honest, the document should reflect what's actually executable, not an aspirational version of your team.

**Section 1, "What We're NOT Doing"**This is often the most valuable part of the whole document. It's easy to read a GTM plan and see ten channels to pursue. What's harder, and more useful, is being explicit about what you're deliberately *not* doing and why. If Claude's exclusion list doesn't match your instincts, that's worth a follow-up conversation.

**Section 2, Where They Congregate**The prompt asks Claude to verify that communities exist and are active, not just name them. When you read this section, spot-check two or three of the specific communities it mentions. If a subreddit has 200 members and hasn't posted in six months, that's not a real channel for you.

**Section 4, Channel Strategy**The most complex section. Each channel gets its own breakdown with specific tools and a budget allocation. When reading it, check the math: do the individual budget allocations add up to your {{marketing\_budget}}? If the totals don't align, push back with a follow-up prompt.

**Section 6, SEO Keywords**Claude is instructed to assess intent and competition, not invent search volumes. Treat this as a starting list, not a final keyword strategy. Before you build content around any keyword, verify it in a tool like Google Search Console or Ahrefs, even the free versions.

### 3.3 What Claude Produces

Once Claude finishes, you should have a document that covers your product's complete go-to-market picture. Let me walk through the kind of things you'll see in a well-generated GTM output, using Nurturo (the app I'm building in this course) as the example.

**Growth motion:** For Nurturo, Claude identified product-led growth as the primary motion, not outbound sales. This makes sense for the product because it has a structural viral loop built into how it works: when one parent joins and submits an expense, they naturally invite the other parent to accept it. Every new user potentially brings another user with them. That's a meaningful CAC reduction right out of the gate.

**Channel strategy:** Claude flagged Apple Search Ads as the highest-priority paid channel at this stage, because the product is an iOS app, the search intent is high, and competition for the relevant keywords is low. For context on budget: with around $200/month in Apple Search Ads targeting people already searching for co-parenting expense tools, Claude estimated roughly 50,160 installs per month. Not viral scale, but meaningful for early stage.

On the channels to skip: Meta, Instagram, TikTok, LinkedIn, none of them make sense at year one. The audience is reachable, but the CAC would be too high for the budget and the intent isn't there. Maybe year two. Not now.

**Budget:** Claude's output will give you a breakdown of how to allocate your {{marketing\_budget}} across your specific channels, not a generic split, but one grounded in the channel strategy it's recommended.

**Risks:** For a solo founder, the biggest risk is almost always founder time. Managing development, support, marketing, and sales simultaneously is genuinely hard. I'll cover the time management side of that when we get into the product management section later in the course.

### 3.4 Reading and Reviewing the Output

Same principle as every other document in this phase: don't just accept it wholesale. Read it. Does the ICP match what you know about your user? Does the channel recommendation match what you've seen in your own research? Are the year-one targets realistic given your market size?

Use Claude to go deeper on anything that's unclear. If there's a term you don't recognise, highlight it and ask Claude to explain it. The document is a starting point, your job is to review it until it genuinely reflects your strategy, not just a plausible-sounding AI output.

ℹ️

Even though I go through the output fairly quickly in the video, I've spent years reading and working with documents like this. You should slow down and spend real time on yours. Read every section. Understand every recommendation. This is the document you'll be executing against.

---

## 4\. Try It Yourself

### Example: Your GTM Prompt Run

Here's what to do:

1. Open Claude Desktop and make sure Cowork is pointed at your project folder
2. Copy the prompt template above and replace the placeholder values with your product name and type
3. Run the prompt and let Claude work through it, this may take a minute or two
4. Open the output document in Obsidian (or your notes tool)
5. Read through it section by section, following the structure described above

**Now try this:** After Claude generates the document, pick the one channel recommendation you're most uncertain about, the one where you're not sure if Claude got it right. Ask Claude directly: "Why did you recommend \[channel\] over \[alternative\]? What in the research supports this?" Make it defend its reasoning.

---

## 5\. Watch Out For These

⚠️

****Generic output that ignores your research**  
Here's why this happens: if Cowork isn't correctly pointed at your project folder, Claude won't have access to your previous documents and will fall back on generic GTM advice.  
The way I avoid it: always verify Cowork is configured and the folder is accessible before running any of these prompts.  
If you've already hit this: re-run the prompt with Cowork pointing at the right folder. The difference in output quality is significant.

⚠️

****Treating the GTM doc as a to-do list for day one**  
Here's why this happens: the document covers a lot of channels and tactics, and it's tempting to try to do all of them at once.  
The way I avoid it: use the "What We Will NOT Do" section as your filter. The GTM doc is a full picture, you execute it in phases. Year one is about focus, not coverage.

⚠️

****Skipping the review**  
Here's why this happens: the output looks professional and thorough, so it's easy to assume it's right.  
The way I avoid it: I always read the full document. Even if I'm going quickly on video, I go back and read it properly before moving on. AI output is a first draft, not a final answer.

---

## 6\. Practice

### Exercise 1: Run the GTM Prompt

**What to do:** Copy the prompt from Section 3.1\. Fill in the four placeholders, `{{product_name}}`, `{{domain}}`, `{{marketing_budget}}`, and `{{team_size}}`then run it in Cowork. Let Claude generate the full document and save it to your project folder.

**A nudge if you're stuck:** If the output feels too generic, check whether Cowork has access to your previous documents. Add a note to the prompt that says "refer to the market research and investor summary documents already in this folder."

**How you'll know it's working:** The document references your specific product, your ICP, and your market by name, not generic placeholders. The channel recommendations are specific and reasoned, not a list of every marketing channel that exists.

### Exercise 2: Challenge One Recommendation

**What to do:** Pick one channel or budget recommendation from your GTM doc that you're not 100% sure about. Ask Claude to explain the reasoning behind it using your specific research as the source.

**What this is practising:** Critical review of AI output. The goal isn't to accept everything Claude writes, it's to understand it well enough that you could defend the strategy yourself if someone asked you about it.

---

## 7\. You Should Be Able to Build This Now

Here's what you can put together with what we just covered:

- A complete, research-grounded go-to-market strategy document for your product
- A clear view of which channels to pursue in year one and which to park for later
- A realistic budget framework for early-stage marketing

### Check Yourself

- \[ \] I've run the GTM prompt and have a document saved in my project folder
- \[ \] I've read through the full document, not just skimmed it
- \[ \] I understand my primary growth motion and why it fits my product
- \[ \] I know which channels we're pursuing and which we're deliberately skipping
- \[ \] I've completed both exercises above

✅

If you're ticking those boxes, you've completed Module 2\. That's a real achievement, you now have six documents that together form the strategic foundation for your entire product. Next up: Module 3, where we take all of this into specs, prioritisation, and your project board.

### If Something's Not Working

⚠️

****Claude produces a GTM doc that doesn't mention my product by name**  
****What's happening:** Cowork likely doesn't have access to your previous documents, so Claude is working without context.  
****How to fix it:** Check your Cowork folder configuration in Claude Desktop settings. Make sure it's pointing at the folder where your project documents are saved, not a parent folder or the wrong directory.

---

## The Short Version

Here's what I want you to walk away with:

- **Building is the easy part now.** Everyone can build. Selling is the hard part, and that's exactly why we document the GTM strategy before we write a line of code.
- **The order matters.** The GTM document works because it's grounded in everything that came before it, the research, the technical doc, the UX doc, the investor summary. That's the whole point of doing things sequentially.
- **Focus beats coverage.** In year one, you're not doing every channel. You're going deep on one or two, based on what your specific product and market support. Everything else is deferred, not abandoned.
- **What you can do now:** You've got the playbook. Module 3 is where we translate all of this into specs and start making it real.

---

## Quick Reference

### GTM Prompt Inputs

The full prompt is in Section 3.1\. Fill in before running:

```
{{product_name}}       — your app name (e.g. Nurturo)
{{domain}}             — your validated domain (e.g. nurturo.app)
{{marketing_budget}}   — monthly marketing & sales budget (e.g. $500)
{{team_size}}          — your team description (e.g. solo founder, founder + 1 part-time)

```

### Module 2 Documents: What We Built

| Document                | Lesson   | What It Does                                                  |
| ----------------------- | -------- | ------------------------------------------------------------- |
| Market Research Summary | M2 L1–L2 | Validates the market; go/no-go checkpoint                     |
| Technical Document      | M2 L3    | Backend architecture; what we're actually building            |
| UX/UI Document          | M2 L4    | Design philosophy; key flows; screen inventory                |
| Investor Summary        | M2 L5    | Stakeholder-facing; the "will this make money?" question      |
| GTM Document            | M2 L6    | Sales and marketing playbook; channel strategy; year-one plan |

### GTM Sections to Know

```markdown
Primary Growth Motion     — how the product grows (PLG, paid, SEO, etc.)
Ideal Customer Profile    — who the first paying customer is, exactly
Channel Strategy          — pursue / defer / skip, with reasoning
Budget Guidance           — realistic monthly allocation by channel
What We Will NOT Do       — deliberate exclusions in year one
Viral / Referral Loop     — structural growth mechanism (if it exists)
Year-One Milestones       — success metrics 12 months post-launch
Key Risks                 — most likely failure modes + mitigations

```

---

## Resources

### Tools Used

- [Claude Desktop](https://claude.ai/download?ref=deletosh.com)local desktop app, required for Cowork MCP integration
- [Obsidian](https://obsidian.md/?ref=deletosh.com)where documents are saved (any notes tool works)

---

## Questions I Get Asked

**Q: Do I need to do a separate GTM document if I'm just building for myself or testing an idea?**

Honestly, yes, still do it. Even if you're not raising money or building a team, the act of writing this down forces you to think through who you're actually building for. I've seen a lot of founders skip it and then spend six months wondering why nobody's finding their product. The document doesn't have to be perfect. It just has to exist.

**Q: What if Claude's channel recommendations don't match what I expected?**

That's worth paying attention to. Either Claude has picked up something from the research that you hadn't fully weighed, or it's missing context. Ask it why. Have it walk you through the reasoning. If you disagree after that, update the document to reflect your own judgement. It's your strategy, not Claude's.

**Q: How do I know I'm ready for Module 3?**

If you have all five documents from Module 2 saved in your project folder and you've actually read through them, you're ready. Don't wait until everything feels perfect. The docs will evolve. What matters is that you have a foundation to build from.

---

## 💬 Stuck? Come Talk to Us

💡

If something's not clicking or you want to share what you've built, come find us in Discord.  
****The Foundry →** [****https://discord.gg/hT2TheKzZ**](https://discord.gg/hT2TheKzZ?ref=deletosh.com)  
Drop your question in the right channel. The community's active and I check in there too.

---

## Glossary

**Go-to-Market (GTM) Document:** Your sales and marketing playbook, a strategic document that defines who you're targeting, how you'll reach them, what you'll spend, and what success looks like. Not a brand deck or a content calendar. A strategy. *(first introduced in Module 2, Lesson 6)*

**Product-Led Growth (PLG):** A growth model where the product itself is the primary driver of acquisition. Users invite other users as a natural part of using the product, rather than growth coming from outbound sales or paid ads. *(came up in Module 2, Lesson 6, Neutoro's viral loop is an example)*

**Customer Acquisition Cost (CAC):** The total cost of acquiring a single paying customer. In a product with a viral loop, every user you acquire can potentially bring additional users, which effectively reduces your CAC per acquired pair. *(first came up in Module 2, Lesson 6)*

**Ideal Customer Profile (ICP):** A specific description of the person most likely to buy and get value from your product, including demographics, behaviours, and context. Not "anyone who might use this." The most precise version of your target customer you can write down. *(refined across Module 2, Lessons 5 and 6)*

**Apple Search Ads:** Apple's paid advertising platform, which shows ads in the App Store search results. High-intent channel for iOS apps, users are actively searching for solutions when they see your ad. *(came up in Module 2, Lesson 6 as the primary paid channel recommendation for Neutoro)*
### Module 2, Lesson 5: Generating the Investor Summary
URL: https://deletosh.com/courses/product-path/02-05-generating-investor-summary/
Last updated: 2026-07-16T15:33:31.000Z
## What is an investor summary and how do you write one with Claude?

An investor summary, also called a stakeholder summary, is a non-technical, high-level document that answers one question above all: will this make money?

You write it by prompting Claude to lead with consequences rather than description, pulling from the docs you have already built to produce a nine section first draft you then sharpen. It is worth doing even if the only stakeholder is you, because it forces you to articulate what you are building as if you were pitching it.

**The short version: you prompt Claude to lead with consequences rather than description, pulling from the docs you have already built to produce a nine section summary in a first draft you then sharpen. It reframes your product around what is at stake. The full prompt and review checklist are in The Product Path.**

In the last lesson, we wrapped up the UX/UI document, the front-facing picture of how the product is going to look and feel. Now we're flipping perspective entirely. This lesson is about generating your stakeholder summary: a non-technical, high-level document that answers one question above everything else, *will this make money?*

ℹ️

No corrections or updates to previous lessons at this point. We're building cleanly on everything we've generated so far.

---

## Before We Start

Here's what I'd expect you to have in place before this lesson:

**From previous lessons:**

- Your market research document, saved in Obsidian (or your notes tool)
### Module 2, Lesson 4: Generating the UX/UI Document
URL: https://deletosh.com/courses/product-path/02-04-generate-ux-ui-doc/
Last updated: 2026-07-16T15:33:30.000Z
## What is a UX/UI document and how do you create one with Claude?

A UX/UI document defines how your product looks and how users move through it: design philosophy, UI references, colour palette, typography, component recommendations, key user flows, screen inventory, and empty states.

You create it by building on the technical document and prompting Claude to produce it before any design work starts, so it becomes the blueprint your design follows. Documenting the experience first is what stops you from arguing about buttons three weeks into a build instead of settling how a user actually gets through the product.

**The short version: you build on the technical document and prompt Claude to define screens, flows, and states as a structured UX/UI document before any pixels get pushed. It becomes the blueprint your design work follows. The full prompt and review process are inside The Product Path.**

In the last lesson, we built out the technical side of the picture, the back-end gears, as I like to call them. Now we're shifting perspective. In this lesson, we're going to document the front-facing side: the UX and UI. That means how the product is going to *look*, how users are going to *move through it*, and what makes the experience worth using.

ℹ️

Quick clarification: when I say UX/UI here, I'm talking about documentation, not design. We're not opening Figma and drawing screens. We're writing a document that captures design philosophy, key flows, component direction, and screen inventory, the kind of thing you'd hand a designer or a coding agent before they build anything.

---

## Before We Start

Here's what I'd expect you to have in place before this lesson:

**From previous lessons:**

- Your market research document, saved in Obsidian (or your notes tool). Claude will pull from this to ground the UX document in real findings.
- Your technical document from Module 2, Lesson 3, also saved in your folder.
- Claude Desktop open, with Cowork configured to point at your project folder. We're staying in the same task/context from the previous lesson.

**Tools / setup you'll need:**

- Claude Desktop (local desktop app, not the browser version)
- Obsidian (or whichever notes tool you're using) with your project folder accessible
- The UX/UI prompt, it's in Section 3.2 of these notes. Fill in the two placeholders (`{{product_name}}` and `{{platform}}`) before you run it.

**By the end of this lesson, you'll:**

- Have a full UX/UI document saved to your project folder
- Understand why this document matters before you write a single line of code
- Know what to look for and how to review what Claude produces
- Have a clear picture of the key flows your product needs to support, mapped out before you start building

---

## What Is This Lesson About?

**Duration:** \~12 minutes video + \~30 minutes for your own run  
**Skill Level:** Intermediate  
**What You'll Build:** A UX/UI reference document covering design philosophy, UI references, colour palette, typography, component recommendations, key user flows, screen inventory, and empty states.

This one's shorter to watch but the document it produces is genuinely one of the most valuable things we make in the whole course. I'll walk you through what to look for when Claude hands it back, because if you just run the prompt and don't read what comes out, you're missing the point.

---

## Watch the Lesson

---

ℹ️

****How I'd suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section, pausing the video at the timestamps I've noted. After that, this guide is your reference, you shouldn't need to rewatch to look something up.

---

## What We're Covering

Here's what I'm walking you through in this lesson and why it matters if you're trying to ship real things:

- **Why UX documentation comes before design**: most people get this backwards, and it costs them
- **How to write and run the UX/UI prompt**: same pattern as the technical doc but with a designer's lens
- **How to read and validate the output**: what to look for, what to question, and where your own judgment matters
- **The flows Claude will map for you**: onboarding, core actions, and the key decision points in your product
- **Screen inventory**: knowing what screens your app needs before anyone touches a code editor

---

## 1\. Let's Set the Scene *(\~0:00)*

In the last lesson we built out the technical document, the "back-end gears." Now we're flipping to the front.

The UX/UI document is essentially answering one question: what does this product actually *feel like* to use? Not the code that makes it work. Not the database schema. The experience, the flows, the colours, the moments where a user either gets it or doesn't.

And we're doing this now, at the documentation stage, because this is exactly where most builders mess up. They skip straight from research to code and then end up having long discussions with developers about whether buttons should be round, when the real question they should have answered three weeks earlier is: how does a user even get to that screen?

We're not building anything in this lesson. We're documenting. Just like in the last lesson, the whole job here is to produce a document we can stand behind before a single line of code gets written.

---

## 2\. The Core Idea

### 2.1 Technical Document vs UX/UI Document

Think of these two documents as two halves of the same picture.

The technical document (Module 2, Lesson 3) covers how the app works under the hood, the architecture, the data layer, the integrations. The UX/UI document covers how the app *presents itself*the visual language, the flows, the experience at the surface.

Together, they give you a complete picture of what you're building before you commit to building it.

### 2.2 Why Research-Grounded UX Matters

This is where the research from Lessons 1 and 2 pays off in a way that's hard to appreciate until you see it.

Because we did real research, including looking at competitors, their reviews, and their weak spots, Claude can now make design decisions that are actually reasoned. It's not just picking a colour palette out of the air. It's looking at what the category leader does, looking at what their users hate, and building something different with a purpose.

ℹ️

In my own run, Claude recommended a colour palette designed to "allow trust without being cold", and then explained **why*, citing specific findings from the market research. That level of reasoning only happens because we grounded everything in real data first. This is the research trickling down, and it's the whole reason we spent time on it.

### 2.3 How This Connects to Module 2, Lesson 3: Generating the Technical Document

We're staying in the same Claude Cowork task we used for the technical document. That's intentional. Claude has context from everything we've done in this session, the research, the technical spec, the product name. When you run the UX/UI prompt, it picks all of that up and uses it.

If you start a fresh session, you'll lose that context and the output will be noticeably less specific. Stay in the same task.

---

## 3\. Let Me Show You How It Works *(\~0:35)*

### 3.1 Where You Need to Be

You want to be in Claude Desktop, in Cowork, in the same task from last lesson. Your project folder should still be connected, that's where Claude will write the document when it's done.

Same setup as the technical document lesson. If it worked then, it'll work now.

### 3.2 The Prompt

Here's the full prompt. Fill in the two placeholders before you run it: replace `{{product_name}}` with your app name (e.g. `Nurturo`) and `{{platform}}` with your product's primary platform (e.g. `mobile`, `web`, or `mobile and web`). Everything else copies as-is.

```text
You are a senior product designer specialising in SaaS products for solopreneurs and lean teams.

You will find the market research and technical document in the folder for {{product_name}}.

Your job is to produce a comprehensive UX/UI Overview document in Markdown that the development team can build from.

Output filename: App - {{product_name}} - UX-UI.md

Platform: {{platform}}

---

## Input

You will receive:

1. A market research report (in the folder) — your primary source for understanding what the product does, who it serves, its competitive landscape, and every UX-relevant insight about user pain points and competitor failures.
2. A technical document (in the folder) — reference this for the chosen tech stack, framework, and platform. Your design system choices must align with what has already been decided technically.
3. Product name — it is in the file names.
4. Product description — defer to the market research. Do not ask.

---

## Design System Selection

Choose the component library, icon set, and typographic system that fits this product. Do not apply a generic template.

Before selecting any design system component, reason through these questions:

- Platform: Is this a native mobile app, a web app, a desktop app, or cross-platform? Each has different component ecosystems, type conventions, and interaction patterns.
- Stack alignment: What does the technical document specify? Your design system must be compatible with the framework already chosen. Do not recommend components that conflict with the technical stack.
- Target audience: Does the audience expect a polished professional tool, a consumer app, an enterprise interface? The design language should match their expectations.
- Ecosystem fit: Are there dominant, well-maintained component libraries for this platform and framework combination? Prefer options a small team can work with and extend.

Justify each design system choice in 1-2 sentences.

---

## Constraints

- Build audience: A small design-and-dev team who will build directly from this document.
- Depth level: Design-direction level — describe what to build and why, not pixel-level specifications. The document should be actionable enough that a designer can open their design tool and start without asking questions.
- Accessibility: WCAG AA minimum as a baseline. Note any domain-specific accessibility requirements.
- Do not make Figma-specific references — the team may use any design tool.

---

## Document Structure
 
Follow this structure precisely. Every section is required unless marked (if applicable).

### 1. Design Philosophy

Write 3-5 design principles specific to this product's domain and users. Each principle should have:

- A one-word label (e.g. "Trust", "Clarity", "Speed")
- A 1-2 sentence explanation grounded in what the research reveals about the target user

End with an "Avoid" line listing anti-patterns for this audience.

### 2. Design References

Identify 2-3 real products whose design patterns are relevant. For each:

- Product name and URL
- What to emulate (3-5 specific design decisions)
- What to avoid (1-2 things that don't transfer to this audience)

Search the web to verify these references exist and are current. Pick products the target users actually know, or that solve similar UX problems. At least one reference should be from the product's own industry.

### 3. Brand Direction

#### Tone

5 adjective descriptors with 1-sentence explanations, tailored to the product's domain.

#### Color Palette

A table with these columns: Role, Color Name, Hex, Usage. Include at minimum:

- Primary + Primary Hover
- Secondary (CTA) + Secondary Hover
- Background, Surface, Border
- Text Primary, Text Secondary, Text Muted
- Success, Warning, Error

Choose colors that match the product's domain and audience. Conservative or professional domains get muted, trust-signalling palettes. Consumer or creative domains get bolder palettes. Include accessibility notes confirming key combinations meet WCAG AA.

#### Typography

Select a typographic system appropriate for the platform specified above:

- Native mobile (iOS/Android): defer to the platform's native type system (SF Pro for iOS, Roboto/Material for Android) or a cross-platform alternative if the framework supports it. Provide point sizes appropriate for mobile.
- Web apps: choose a Google Font or system font appropriate for the product's tone. Provide a type scale table: Element, Size, Weight, Line Height.
- Cross-platform: choose a font available across all target platforms and justify the choice.

Justify your font choice in 1-2 sentences. Reference the technical document's platform and framework choice.

### 4. Component Library

State the component library chosen for this platform and stack (referencing the technical document). Then identify product-specific custom components that will need to be built — give each a one-sentence description of what it displays.

### 5. Key User Flows

Identify the 3-5 most critical user flows for the MVP. For each flow:

- Flow name
- Mermaid flow diagram showing the happy path with key decision points and branches
- Key considerations — 3-5 UX decisions that matter for this flow, grounded in research findings about user pain points or competitor failures

The flows should cover: onboarding, the core daily or weekly action loop, and the primary value-delivery moment.

### 6. Screen Inventory

Two tables:

Marketing Pages — columns: Screen, Priority (High/Medium/Low), Key Components
App Screens — columns: Screen, Priority (High/Medium/Low), Key Components

Prioritise based on what the research identifies as core value. High-priority screens are MVP-blocking.

### 7. Empty States

A table covering every list or dashboard screen with columns: Screen, Empty State Message, CTA. Empty states should guide the user toward the next productive action, not just display a blank view.

### 8. Responsive Strategy

- Primary, Secondary, Tertiary device targets — choose based on how the target user actually works, referencing the platform and research
- Breakpoints (if applicable to the platform)
- Platform-specific considerations — 3-5 bullets on what changes across screen sizes or devices

### 9. Accessibility Requirements

Cover: contrast ratios, keyboard navigation, focus indicators, screen reader support, reduced motion support, color-not-sole-indicator. Add any domain-specific accessibility requirements relevant to this product's audience.

### 10. Interaction Patterns

#### Shortcuts and Gestures

Table of 8-12 shortcuts (web) or gestures (mobile) for power users, tailored to this product's core actions.

#### Loading States

How to handle: list or card loading, button actions, long-running processes.

#### Notifications

Toast or notification behavior for success, errors, and pending items.

### 11. Design Handoff Checklist

A checklist of 12-15 items for design-to-dev handoff. Cover: component naming, layout system, component variants, spacing grid, color tokens, responsive or adaptive variants, interactive states, empty states, error states, exported assets, and any platform-specific handoff requirements.

### 12. Design System Documentation

Outline for a component documentation instance (e.g. Storybook for web, equivalent for mobile) with three sections: Foundations, Components, Patterns.

---

## Research & Gap-Filling

- Mine the research report for every UX-relevant insight: user pain points, competitor UX failures, workflow descriptions, user demographics, and any explicit UX recommendations.
- Reference the technical document for all stack and platform decisions before making design system choices.
- Search the web to find and verify real design references in the product's domain. Do not guess at URLs — confirm they exist.
- Ground every design decision in either a research finding or a known UX principle.

---

## Quality Standards

- Flow diagrams must use Mermaid and render cleanly in Markdown.
- Color hex values must be real, usable values — not placeholders.
- The document should be actionable — a designer should be able to open their design tool and start building from this spec without further clarification.
- Target length: 250-400 lines of Markdown.

```

💡

The prompt asks Claude to reference the technical document you generated in the previous lesson. This is why you want to stay in the same Cowork task, Claude already has that context. If you start a fresh session, it won't know what stack was chosen, and the design system section will be less specific.

### 3.3 Understanding the Prompt

A few notes on the key sections, read these once when you're first learning the prompt.

**Design System Selection**No design system is prescribed. Claude derives the component library, icon set, and type system from the platform and the technical document. A React Native app gets a very different set of components than a Next.js web app. A healthcare product gets different typography than a consumer tool. Claude works this out from the documents already in the folder, which is why the technical document comes first.

**Section 2 (Design References)**Claude will name real products as reference points. Go and look at them. Don't take its word for it. In my own run, it cited the category leader in my space as a *negative* reference (users hate specific things about the experience), and an adjacent product as a positive reference. When I went and looked at both, I thought, yes, that's exactly right. You want to be able to say "I looked at this and I agree." If you disagree with a reference, note it and adjust.

**Section 5 (Key User Flows)**This is the most important section in the whole document. Claude will map the critical flows as Mermaid diagrams, and if you're in Obsidian, these render automatically. Read each flow carefully. The detail it captures (like "solo mode is a first-class path because not every user has a co-parent ready to invite") comes straight from the research. If a step looks wrong, that's a signal worth acting on before you write any code.

**Section 6 (Screen Inventory)**Claude will produce a list of every screen your app needs. For a mobile product especially, it's easy to underestimate how many distinct states an app has. Having this list before you build means nothing gets forgotten mid-sprint.

**Sections 3 and 4 (Brand Direction and Components)**Hold these lightly. They're a reasonable starting point, not a final decision. In my own run I wasn't keen on the typography recommendation, that's fine. The document is a draft. Take what makes sense, adjust what doesn't.

**{{platform}} placeholder**This genuinely changes the output. `mobile` gets a native-first type system and touch-optimised interaction patterns. `web` gets a web component library and keyboard shortcuts. `mobile and web` gets both considered. Set it accurately.

### 3.4 Paste It In and Let It Run

Copy the prompt from Section 3.2\. Fill in the two placeholders, then paste it into the Cowork input area. Give it a few minutes, the output is longer than a typical chat response.

When it's done, you'll see it appear in your Obsidian folder (or whichever notes tool you're using) as `App - [product name] - UX-UI.md`.

---

## 4\. How to Read What Claude Gives You *(\~2:55)*

Don't just skim it. Here's what I look for, and what I want you to look for in yours.

### 4.1 Design Philosophy

This is the section that tells you *why* the app should look the way it does. If you did your research properly, Claude will tie this back to specific findings, things your target users value, things competitors got wrong, the emotional register your product should hit.

Read this carefully. If it doesn't feel grounded in your research, something's off in the way you set up the prompt or the context.

### 4.2 UI References

Claude will name actual products or sites as reference points, things to emulate and things to avoid. Go and look at them. Don't take its word for it.

In my own run, it cited the category leader in my space as a negative reference (they have low ratings and users hate specific things about the experience), and it cited another product in an adjacent space as a positive reference. When I went and looked at both sites, I thought, yes, that's exactly right.

That moment of validation is important. You want to be able to say "I looked at this, and I agree." If you disagree with one of the references, note it and adjust.

⚠️

****Don't just accept the references blindly.** Claude is pulling from the research, but you know your space. If it's referencing something that doesn't fit, push back on it, either by editing the document or running a follow-up prompt.

### 4.3 Key User Flows

This is probably the most important section in the whole document.

Claude will map out the critical flows in your product as Mermaid diagrams, and if you're in Obsidian, these render automatically. You'll see the actual flowchart, not just the code.

For my app, it mapped:

1. **Onboarding flow**: from launch to full app access, including the co-parent invite decision
2. **Submit expense flow**: the core action, with a target of under 15 seconds
3. **Approve/dispute flow**: how the other party responds to an expense
4. **Report review flow**: how users access and review monthly summaries

Before this document existed, that second flow was just an idea. Now it's a chart. And the detail it captures, like "solo mode is a first-class path because not every user has a co-parent ready to invite", that came straight from the research.

This is where the planning pays off. Read each flow, check it against what you know about your users, and mark anything that doesn't ring true.

### 4.4 Screen Inventory

Claude will produce a list of every screen your app needs. For a mobile product, this is especially useful because it's easy to underestimate how many distinct states an app has.

It'll also cover empty states, what happens when there's nothing in the app yet. This sounds minor but it's a UX decision that often gets forgotten until a developer asks about it mid-build. Having it here means it won't get skipped.

### 4.5 Colour, Typography, and Components

Read these, but hold them lightly. Claude's suggestions here are reasonable starting points, not final decisions.

I'll be honest, in my own run, I wasn't keen on the typography recommendation. That's fine. The document is a draft, not a decree. Take what makes sense, adjust what doesn't.

For components, Claude will likely suggest things like shadcn/ui or native base. If you're not sure what those are, ask Claude to explain them or do a quick search. Don't skip past unfamiliar terms, they'll come up when you start building.

---

## 5\. Why This Document Matters So Much *(\~9:10)*

I want to stop here for a second because I think this is worth saying plainly.

Most people building apps, especially solo, spend enormous amounts of time debating authentication flows, discussing button styles with developers, and changing their minds about onboarding halfway through a sprint. All of that is avoidable if you do this work first.

This document answers those questions before they become arguments. It says: here's the onboarding flow, here's the screen inventory, here's what we avoid and why. It doesn't mean nothing will change, things always change, but you're starting from a position of clarity rather than guesswork.

And the second thing: when you eventually use Claude Code to build this thing, you'll be handing it documents like this one. The more specific and reasoned your documentation, the better the code it produces. We're building our own runway here. Every document we write is a clearer set of instructions for what comes later.

🔥

If you have people in your life who might be your target users, show them the flows from this document. Not the whole thing, just the diagrams. Ask them: does this make sense? Would you use this? That five-minute conversation is worth more than a week of coding.

---

## 6\. Watch Out For These

⚠️

****Starting a new Cowork task**  
If you start a fresh session instead of continuing in the same task, Claude loses all the context it built up, the research, the technical doc, the product name. The output will be noticeably more generic. Stay in the same task.

⚠️

****Not reading the output**  
I see this a lot. People run the prompt, see a long document appear, and assume it's done. Read it. Especially the flows. Claude is doing real reasoning here, but it can only work with what it was given. If something looks off, it's either a prompt issue or a gap in your research, both of which are fixable.

⚠️

****Treating this as a final design doc**  
It's not. It's a reference document. The colours might change. The typography might change. That's fine. The flows and the design philosophy are what matter most at this stage, those should stay pretty stable.

---

## 7\. Practice

### Exercise 1: Run the Prompt for Your Product

**What to do:** Copy the prompt from Section 3.2\. Fill in `{{product_name}}` and `{{platform}}`, then run it in Claude Cowork. Confirm the document appears in your project folder.

**A nudge if you're stuck:** Make sure you're in the same Cowork task as your previous documents. If the folder reference isn't working, check that Cowork is still pointed at the right directory.

**How you'll know it's working:** You'll see `App - [your product name] - UX-UI.md` appear in your Obsidian vault (or notes folder). Open it and confirm it has sections for design philosophy, flows, and screen inventory.

### Exercise 2: Validate One Flow

**What to do:** Pick the most important flow in your product, probably onboarding. Read through it step by step and ask yourself: does this match how a real user would actually do this? Is there a step missing? Is there a step that would cause friction?

**What this is practising:** Reading AI output critically. The goal isn't to accept what Claude produced, it's to engage with it and make it better.

---

## 8\. You Should Be Able to Do This Now

Here's what you can put together with what we just covered:

- Run a UX/UI documentation session in Claude Cowork, grounded in your market research
- Read and critically evaluate the output, not just skim it
- Use the user flow diagrams as a communication tool before any code gets written

### Check Yourself

- \[ \] I have an `App - [product name] - UX-UI.md` file saved in my project folder
- \[ \] I've read the design philosophy section and it makes sense for my product
- \[ \] I've looked up the UI references Claude cited and formed a view on them
- \[ \] I've read through at least one key user flow and validated it against what I know about my users

✅

If you're ticking those boxes, you've done the work. The next lesson is where we go broader, the investor/product summary document. But first, sit with this one. Read the full UX/UI doc you've produced. You've just described your product's experience in more detail than most solo builders ever do.

### If Something's Not Working

⚠️

****The document didn't save to my folder**  
****What's happening:** Claude wrote the document to chat instead of to disk, usually means the Cowork folder reference wasn't picked up.  
****How to fix it:** Check that Cowork is connected to your folder. Re-run the prompt. The output filename is specified in the prompt itself (`App - {{product_name}} - UX-UI.md`), make sure you've filled in the placeholder before running.

⚠️

****The Mermaid diagrams aren't rendering**  
****What's happening:** You might be viewing the file in a tool that doesn't render Mermaid by default.  
****How to fix it:** Open the file in Obsidian, it renders Mermaid natively. If you're using a different notes tool, check whether it supports Mermaid or find a free online Mermaid renderer to paste the diagram code into.

---

## The Short Version

Here's what I want you to walk away with:

- **The UX/UI document is not design work**: it's documentation. You're capturing how the product should feel before anyone starts building it.
- **Research grounds everything**: the colour rationale, the UI references, the flows. None of it is arbitrary if you did the research.
- **The user flows are the most important part**: read them carefully, validate them against real users if you can, and treat them as a shared language between you and whoever builds this.
- **What you can do now:** Describe your product's complete user experience, from first open to core action, in a format you could hand to a designer, a developer, or an AI coding agent.

---

## Quick Reference

### UX/UI Document Prompt

The full prompt is in Section 3.2\. Fill in before running:

- `{{product_name}}`your app name (e.g. `Nurturo`)
- `{{platform}}`your primary platform (e.g. `mobile`, `web`, or `mobile and web`)

### What the Document Produces

```
Design philosophy          — why the product looks and feels the way it does
Design references          — what to emulate and what to avoid, with rationale
Colour palette             — with reasons tied to the research
Typography                 — font and type scale appropriate to the platform
Component library          — derived from the technical stack, plus custom components
Key user flows             — Mermaid diagrams for onboarding, core actions, etc.
Screen inventory           — every screen the product needs
Empty states               — what happens when there's nothing to show
Responsive/device strategy — how the product adapts across screen sizes
Accessibility requirements — WCAG AA baseline plus domain-specific notes
Interaction patterns       — shortcuts/gestures, loading states, notifications
Design handoff checklist   — what a designer needs to hand off to a developer

```

---

## Resources

### Tools Used

- [Claude Desktop](https://claude.ai/download?ref=deletosh.com)run via Cowork with folder access
- [Obsidian](https://obsidian.md/?ref=deletosh.com)for viewing and storing the output (Mermaid renders natively here)

### Concepts Worth Looking Up

- **Mermaid diagrams**: a text-based format for flowcharts that Obsidian (and Claude) supports natively. [mermaid.js.org](https://mermaid.js.org/?ref=deletosh.com) has live preview if you want to test diagrams outside of Obsidian.
- **shadcn/ui**: a component library Claude often recommends for web products. Worth knowing what it is before you get to the build phase.

---

## Questions I Get Asked

**Q: Do I need to be a designer to review this document?**

No. The most important thing is whether the flows make sense to you, not whether the typography choice is correct. You don't need a design eye to read a flowchart and say "wait, this step doesn't make sense." Trust your instincts as a user of your own product.

**Q: Can I edit the document Claude produces?**

Absolutely, and I'd encourage it. This is a living document at this stage. If Claude's colour recommendation doesn't fit your product, change it. If a flow is missing a step, add it. Claude gave you a strong first draft, your job now is to make it yours.

**Q: My product is a web app, not a mobile app. Does this still work?**

Yes. The prompt I gave you works for web, mobile, or anything in between. Just be explicit in your prompt about the platform, Claude will adjust the screen inventory and flow assumptions accordingly.

**Q: How do I know I'm ready for the next lesson?**

If you've got the document, you've read it, and you can explain what your product's onboarding flow looks like, you're ready.

---

## 💬 Stuck? Come Talk to Us

💡

If something's not clicking or you want to share what you've built, come find us in Discord.  
****The Foundry →** [****https://discord.gg/hT2TheKzZ**](https://discord.gg/hT2TheKzZ?ref=deletosh.com)  
Drop your question in the right channel. The community's active and I check in there too.

---

## Glossary

**UX/UI document:** A written specification of how a product should look and feel, covering design philosophy, visual direction, user flows, and screen inventory. Not a design file; a reference document. *(first used in Module 2, Lesson 4)*

**Mermaid diagram:** A text-based format for writing flowcharts and diagrams that renders automatically in Obsidian and several other tools. Claude uses it to map user flows. *(first came up in Module 2, Lesson 4)*

**Cowork:** Claude Desktop's multi-turn working environment where you can connect Claude to a local folder so it reads and writes files directly. *(first introduced in Module 2, Lesson 3 - Generating the Technical Document)*

**Empty state:** The screen a user sees when an app has no content yet, for example, when they've just signed up and haven't added any data. Defining these up front prevents them being an afterthought during build. *(first came up in Module 2, Lesson 4)*

**Screen inventory:** A complete list of every distinct screen or view an app needs to have. Produced at the documentation stage so nothing gets forgotten during build. *(first came up in Module 2, Lesson 4)*

**shadcn/ui:** A popular React component library that Claude often recommends for web products. Worth looking up before you get to the build phase. [ui.shadcn.com](https://ui.shadcn.com/?ref=deletosh.com) *(first came up in Module 2, Lesson 4)*
### Module 2, Lesson 3: Generating the Technical Document
URL: https://deletosh.com/courses/product-path/02-03-generate-technical-document/
Last updated: 2026-07-16T15:33:28.000Z
## What is a technical document and how do you generate one with Claude?

A technical document is the blueprint that answers what exactly you are building and how: the app name, the recommended stack, the architecture, cost projections, and environment setup.

You generate it by feeding your validated research into one long, deliberate prompt in Claude Desktop's Cowork mode, which writes the document straight into your project folder. The prompt is deliberately long because that is what gives Claude enough context to make real architecture decisions rather than generic suggestions.

**The short version: you feed your validated research into one long, deliberate prompt that names the app, recommends a stack, and maps the architecture in a single pass. A longer prompt is what gives Claude enough context to make real decisions. The complete prompt and setup live in The Product Path.**

## Before We Start

Here's what I'd expect you to have in place before this lesson:

**From previous lessons:**

- Your completed market research document from Module 2, Lessons 1 and 2, saved in Obsidian or your notes tool of choice. Claude writes the technical document based on this, so it needs to exist and be accessible.
- Your project folder set up in Claude Desktop's Cowork tab, you'll configure this at the start of the lesson if you haven't already

**Tools / setup you'll need:**

- Claude Desktop (the local desktop app, not the browser version)
- Obsidian with your research document already saved inside it
- The Claude Cowork tab available in your Desktop app

**By the end of this lesson, you'll:**

- Have an app name you've validated (not just vibed with)
- Understand what the technical document is and why it exists before you write a single line of code
- Have used Claude's Cowork mode to generate a full technical architecture document and write it directly to your folder
- Know how to read and work with the document Claude produces

---

## About This Lesson

**Duration:** \~20 minutes video + \~30 minutes for your own run  
**Skill Level:** Intermediate  
**What You'll Build:** A technical overview document, your app's architecture, stack choices, cost projections, and environment setup, saved directly into your project folder

This is the first document in the documentation phase. It's the one that answers the question: "What, exactly, are we building and how?" Even if you hand this off to an agency instead of building it yourself, this document gives whoever's building it a clear blueprint to work from.

---

## Watch the Lesson

---

ℹ️

****How I'd suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section. After that, this guide is your reference, you shouldn't need to rewatch to look something up.

---

## What Will This Lesson Cover?

Here's what I'm walking you through in this lesson and why it matters:

- **Naming your app with Claude**: how to use AI as a naming partner without just going with whatever it says first
- **Validating the name**: domain availability, trademark check, and what to look for before you commit
- **The four documents this module produces**: what each one is for and how they connect
- **Setting up Claude's Cowork tab**: what it is, how it connects to your folder, and why this is different from a regular chat
- **The technical document prompt**: the structure behind the prompt and why each section exists
- **Reading the output**: what Claude produces and how to work with it

---

## 1\. Let's Set the Scene *(\~0:00)*

Before I start generating any documents, I want to give the app a proper name. We've been calling it "the co-parenting app", which works for talking about it, but doesn't work for building it. Your file names, your folder structure, your prompts, they all need a consistent identifier.

So in this lesson, I'm naming the app first. Then I'm generating the technical document. And I want to show you how I used Claude to help with the naming, and, importantly, how I pushed back on what it first suggested.

In this module overall, we're going to produce four documents. The technical document is first. Then we'll generate a UX and branding overview. Then a stakeholder summary, which is helpful even if the only stakeholder is you, because it forces you to articulate what you're building as if you're pitching it. And finally, a go-to-market document. Combined with the research report from the previous two lessons, that's five foundational documents before we write a single line of code.

That might sound like a lot. But every one of those documents feeds something downstream, and the time you spend here makes everything that comes after significantly faster.

---

## 2\. Naming the App

### 2.1 How I Prompted for Names

My app doesn't have a name yet, so before I generate any documents, I want one. And yes, I'm going to use Claude to help.

Here's the prompt structure I used:

```text
Based on the research and the sensitivity of what the name can imply, 
can you suggest names for my app? For context, here's a quote from an 
App Store review I found: [paste the review quote you found earlier].

If you need any clarity before suggesting names, ask me first.

```

That last line, asking Claude to ask me questions before diving in, is something I use consistently. It gets much better results than just letting it guess what you want.

Claude came back with a set of clarifying questions before giving me any names:

1. **What emotional tone do you want the app to convey?** (Calm? Empowering? Professional? Playful?)
2. **How explicitly should the name signal the app's purpose?** (Should people instantly know it's for co-parents, or something more subtle?)
3. **Any words or associations to avoid?**

These questions aren't Claude padding things out. They're genuinely useful to answer, because they force you to be clear about things you might have left fuzzy.

### 2.2 My Answers and Why

Here's how I answered:

**Tone:** Calm and conflict-reducing, empowering, child-focused, and neutral-practical. I kept the "modern and professional" option off, that leaned too corporate for what I wanted.

**Explicitness:** Somewhere in the middle. I want people to roughly understand what it does, but not so literal that it becomes uncomfortable for someone who has to have it on their phone. Co-parenting situations can be fraught, a name that screams "DIVORCE APP" could feel triggering. But too vague and it's forgettable.

**Words to avoid:** Anything implying conflict, courts, or legal proceedings. Avoid "co" as a prefix (feels too clinical and potentially uncomfortable). Avoid generic-sounding names and coined names that feel fake.

### 2.3 Evaluating What Claude Suggested

Claude came back with a batch of names: Keto, Wellwise, Nora, Clarity, Parento, Kindpath, Parallel, Tandem, Anoma.

None of them were quite right. I pushed it for more, specifically asking for "more branded" options. Claude ran another round (this is where it mentioned it was running sub-agents, doing combinations and variations) and came back with a second batch.

Out of everything it suggested, two stood out to me:

- **Twine**: something about it felt connective. You say it and it sounds like something real.
- **Nurturo**: modern, soft, no hard sounds. Close to "nurture" without being on the nose.

The rest I discarded. And this is an important point: AI is a great brainstorming partner, but your human judgment on naming still matters. You're the one who knows what feels right for the market you've spent time researching. Claude gives you direction. You decide where to actually steer.

🔥

When picking a product name, you want something people can say easily, spell without thinking, and that sounds like a real thing, not a placeholder. Say your shortlist out loud. Tell a friend "go download \[name\]" and watch their face. That tells you a lot.

### 2.4 Validating the Name Before You Commit

Once I had Nurturo as my top choice, I did three quick checks before going any further:

**1\. Google search:** Is anyone already using this name in a meaningful way? I didn't find much, which is a good sign.

**2\. Domain availability:** I went to Namecheap and checked `nurturo.com` and `nurturo.app`. The `.com` was taken (and listed for sale at around $7,000, which I'm not paying, but interestingly that price signals the name has brand power). The `.app` was available at roughly $12/year. That's the one I'm going for.

**3\. Trademark check:** I did a quick search on the US Patent and Trademark Office website (USPTO). Nobody had a registered trademark on Nurturo. Green light.

That whole validation process took less than 10 minutes. Do it before you get attached to a name and start building with it.

⚠️

****Don't skip the trademark check.** It takes five minutes and could save you from a rebrand six months into building. USPTO is free to search, there's no reason not to do this before you commit to a name.

### 2.5 Updating Your Files

Once I had a name, I went back to Obsidian and renamed my research files. I went from a generic "research" naming to a consistent pattern:

```
[AppName] Market Research
[AppName] Market Review

```

In my case, that's `Nurturo Market Research` and `Nurturo Market Review`. I also renamed any related files to match. This consistent naming becomes important later, Claude's prompts reference files by name, and you want that to be predictable and clean.

---

## 3\. The Four Documents This Module Produces

Before we generate the technical document, I want to give you the full picture of what this module produces. We're not just making one thing, we're making four, and they build on each other:

1. **Technical Document**: what we're building, how it's built, what stack it runs on, what it costs to operate. This is the engineering blueprint.
2. **UX / Branding Document**: how the app looks and feels, the experience and tone, key design principles.
3. **Stakeholder Summary**: a concise pitch-style document explaining what the product is, who it's for, and why it matters. Even if the only stakeholder is you, this forces clarity.
4. **GTM (Go-to-Market) Document**: how you're going to launch, acquire users, and position the product in the market.

Plus, from the previous two lessons, you already have the market research. So by the time you finish this module, you'll have five comprehensive documents, all grounded in real research, before a single line of code is written. That's the foundation everything else builds on.

In this lesson, we're doing the first one: the technical document.

---

## 4\. Setting Up Claude's Cowork Tab

### 4.1 What Cowork Is

Cowork is a tab inside Claude Desktop. It's not a regular chat, it's a workspace mode where Claude can see and work with files on your computer directly. When you open Cowork and select a folder, Claude has access to everything in that folder. It can read your documents, write new ones, and update existing ones, without you having to paste anything in.

This is why the desktop app is required. The browser version of Claude.ai doesn't have Cowork, and it doesn't have the file access Claude needs for this to work.

⚠️

****If you don't see a Cowork tab at the top of Claude Desktop, you're probably in the browser version.** The desktop app is a separate download. Go to claude.ai/download and install it. They look similar but they're not the same, the browser version won't have Cowork.

### 4.2 Selecting Your Folder

When you open Cowork, the first thing you'll see is a prompt to select a folder. Click it and navigate to wherever you're storing your project documents, in my case, the folder inside my Dropbox that contains my Obsidian vault files for this project.

A few things to keep in mind about your folder selection:

- **Keep it focused.** Select the folder that contains only your project documents, not your entire Dropbox or desktop. Claude will read everything in that folder as context, so a huge folder with unrelated files will slow things down and muddy the context.
- **The folder needs to already exist.** Create it and move your existing files in before you open Cowork.
- **The path shows up in Cowork.** Once selected, you can see the path in the corner, double-check that it's pointing to the right place before you run any prompts.

After selecting the folder, you should see your files listed in the Cowork sidebar. If you can see your market research document listed there, you're set up correctly and ready to go.

---

## 5\. The Technical Document Prompt

### 5.1 Why I Wrote a Long Prompt (And Why You Should Use It)

This prompt took me a while to get right. I've iterated it over multiple projects, and what you'll find in the prompt library is the version I actually use, not a first draft.

I know long prompts can feel intimidating. But think of it this way: you're giving Claude the information it would need to brief a senior technical architect. The more precisely you do that, the better the output you get back. A vague prompt produces a generic document. A specific prompt produces something you can actually work with.

You don't need to write this prompt yourself, it's in Section 5.2 below. But I want to walk you through its structure so you understand what it's doing and can adapt it for your project.

### 5.2 The Prompt

Here's the full prompt. Fill in the three placeholders before you run it: replace `{{product_name}}` with your app name (e.g. `Nurturo`), `{{monthly_budget}}` with your infrastructure budget (e.g. `$500`), and `{{team_size}}` with your team size (e.g. `2-3 developers`). Everything else copies as-is.

```text
You are a senior technical architect specialising in SaaS products for solopreneurs and lean teams.

You will find the market research in the folder for a new product.

Your job is to produce a comprehensive Technical Overview document in Markdown.

Output filename: App - {{product_name}} - Technical.md

---

## Input

You will receive:

1. A market research report (in the folder) — this is your primary source for understanding what the product does, who it serves, its pricing, competitive landscape, and any technical notes the researcher included.
2. Product name — it is in the research file name.
3. Product description — defer to the market research. Do not ask.

---

## Stack Selection

Choose the best technology for this specific product. Do not apply a generic template.

Before selecting any technology, reason through these questions:

- Platform: Is this product mobile-first, web-first, or both? What do the competitors use, and what does the target user expect on their device?
- Scale: What's the expected user volume at MVP vs. 12 months in? Does that change the infrastructure needs?
- Domain: Are there standard tools or compliance requirements for this product's category (e.g. healthcare, finance, communication, productivity)?
- Complexity: Does the product require real-time sync, background processing, AI inference, file storage, or other non-trivial infrastructure? Choose accordingly.
- Maintainability: With a small team, prefer well-documented, widely adopted technologies over niche choices. The person maintaining this is probably one person.

Justify every technology choice in 1-2 sentences. If you choose between two reasonable options, briefly note why you picked one over the other.

---

## Constraints

- Budget: ~{{monthly_budget}} total infrastructure per month at early scale (0-500 users)
- Team: {{team_size}}
- Depth: Architecture-level only — describe what each component does, how they connect, and why they were chosen. Do not write implementation code. Pseudocode or interface signatures are acceptable only when they clarify architecture (e.g. a provider fallback chain, a job processing pipeline).
- Free tiers: Identify and prefer services with meaningful free tiers for the MVP stage. State clearly which services cost nothing at early scale.

---

## Document Structure

Follow this structure precisely. Every section is required unless marked (if applicable).

### 1. Stack Summary

A single table listing every technology in the stack, with columns: Layer, Technology, Notes. Group by concern area (e.g. Frontend, Backend, Database, Auth, Infrastructure, Monitoring, Third-Party).

### 2. Key Architectural Decisions (if applicable)

If the product requires a non-obvious architectural choice (e.g. a multi-provider AI strategy, a reseller API model, a real-time sync engine, a mobile-first vs. API-first split), dedicate a section to explaining:

- What the decision is
- Why it was made (cite the research)
- How it works at a high level
- A comparison table if relevant

### 3. Infrastructure

Cover:

- Hosting & Deployment — Dev and prod environments, CI/CD pipeline
- Database Schema (Core Tables) — Mermaid diagram showing tables, key columns, and relationships. Core domain tables only (typically 5-10 tables).
- Background Jobs — Table of scheduled/triggered jobs: Job name, Schedule/Trigger, Purpose
- Third-Party Integrations — Table of every external service: Service, Purpose, Tier/Cost at MVP scale

### 4. Authentication & Security

Cover:

- Auth approach — what library or service handles it, and how it is configured for this product
- Data handling policies — what is stored, what is transient, retention periods
- Compliance considerations — GDPR, CCPA, or industry-specific requirements relevant to this product's domain
- Security measures — encryption, rate limiting, CORS, input validation
- Third-party data policies — especially for any AI or data-processing APIs

### 5. API Architecture

- Internal API — Tree diagram of API routes grouped by domain
- External APIs Consumed — Table: API, Purpose, Auth Method
- Key Abstractions — If the product wraps external APIs, describe the abstraction layer at interface level (not implementation)

### 6. Cost Projections

- Per-unit cost breakdowns where applicable (e.g. AI cost per token, storage cost per GB, API cost per call)
- Monthly Cost Projections — Table with three stages: MVP (0-100 users), Growth (100-500 users), Scale (500-2K users). Columns: Stage, Monthly Cost, Breakdown
- Unit Economics — Average cost per user, gross margin at each pricing tier
- Free tier summary — Which services cost nothing at MVP stage and when costs kick in

### 7. Environment Variables

List all required and optional environment variables, grouped by service. Use placeholder values. Mark each as Required or Optional. Do not include actual secrets.

### 8. Development Setup

Step-by-step shell commands to clone, install, configure, and run the project locally. State your assumptions about what the developer already has installed (e.g. Node.js, pnpm, Docker).

### 9. Third-Party Service Setup

For each product-specific service (anything that requires a signup or account), provide:

- Service name and signup URL
- Key configuration steps (2-4 bullets)
- Which model, tier, or plan to use at MVP stage

### 10. Deployment Checklist

Three checklists:

- Pre-Launch — Infrastructure, DNS, SSL, database, env vars, API keys, third-party accounts
- Launch Day — Migrations, deploy, integration verification, critical flow testing, monitoring
- Post-Launch — Backups, alerting, cost monitoring, runbooks, security update cadence

---

## Research & Gap-Filling

- Use the market research as your primary source for understanding the product domain, competitors, pricing expectations, and technical requirements.
- Search the web to fill gaps on: current pricing of third-party services, best practices for this product's domain, and any technology choices not covered in the research.
- Use real, current pricing — if the research figures seem outdated, search and use the current price. Do not estimate.
- Cite your reasoning — when you choose a technology over alternatives, state why in 1-2 sentences.

---

## Quality Standards

- Every table must be properly formatted Markdown.
- Database schema must use a Mermaid diagram and must show foreign key relationships clearly.
- Cost projections must use real, current pricing — search if uncertain.
- The document must be self-contained — a developer joining the team should understand the full architecture from this document alone, without needing to ask questions.
- Target length: 300-500 lines of Markdown.

```

💡

The "Research & Gap-Filling" section instructs Claude to search for current pricing before committing to any number. Pricing for cloud services changes constantly, a document with made-up numbers isn't useful for planning. That's why this is baked into the prompt, not left to chance.

### 5.3 Understanding the Prompt

A few notes on the key sections, read these once when you're first learning the prompt, then you won't need them again.

**Stack Selection**No stack is prescribed. Rather than locking Claude into specific technologies, you're giving it the information it needs to make good choices *for your product*. A mobile app gets a different stack than a web dashboard. A healthcare product gets HIPAA-aware choices. Claude works this out from your research, which is why the research has to be good before you run this.

**Section 2 (Key Architectural Decisions)**This section only appears if your product has something genuinely non-obvious under the hood. A simple CRUD app probably skips it. A product that needs real-time sync, multi-provider AI fallback, or an unusual data model will have something worth capturing here. If Claude includes it, read it carefully, it's explaining a choice that will affect everything downstream.

**Section 3 (Infrastructure / Database Schema)**The Mermaid diagram is the most concrete output in the whole document. Even if you can't read code, you can look at a diagram of boxes and arrows and understand what data your product is tracking and how it connects. If the diagram looks wrong for what you're building, that's a signal worth acting on before you write any code.

**Section 6 (Cost Projections)**Claude is instructed to search for current pricing, not estimate it. Check the numbers against the actual pricing pages for the services it recommended. The per-unit breakdown (cost per AI call, cost per email, etc.) is particularly useful when you're deciding on a pricing model.

**Section 10 (Deployment Checklist)**You won't need this on day one, but you'll be glad it exists when you're prepping to launch.

**Budget and team size placeholders**The `{{monthly_budget}}` and `{{team_size}}` values genuinely affect what Claude recommends. A solo developer on a $200/month budget gets different infrastructure choices than a two-person team with $800/month. Set these to reflect what you're actually working with.

### 5.4 Running the Prompt

Copy the prompt from Section 5.2\. Fill in the three placeholders, then paste it into the Cowork input area, in Cowork it looks slightly different from a regular chat, but it works the same way. Select your model (I'm on Claude Sonnet 4.6, the default) and hit Enter.

Don't paste your research document. You don't need to. Claude can see it already because it's in the folder you selected. Watch the output, you'll see Claude acknowledge it's found the document and then start building a task list for itself:

- Search current pricing for services
- Design the full tech stack
- Write the technical overview
- Save it to the workspace

Then it runs. This takes a few minutes. Walk away. Get water. Let it work.

---

## 6\. Reading the Output *(\~15:30)*

### 6.1 What Claude Figures Out On Its Own

This is the part that genuinely impressed me the first time I ran this. I gave Claude a prompt and a market research document, and it came back having made decisions I would have made myself.

For Nurturo, it figured out:

- **Mobile-first:** From the research, it correctly identified that all competitors are mobile apps. So it recommended React Native with Expo, targeting iOS and Android from a single codebase.
- **Two-tier AI strategy:** It thought through how AI features should be structured in the product without me specifying it.
- **Vendor recommendations with rationale:** It didn't just say "use Postgres", it explained why Postgres made sense for this use case.
- **Cost projections with free tier awareness:** It went through each service in the stack and identified how much it costs at different scale levels. At 2,000 users, the projected monthly cost was around $420\. That's a real number I can plan around.

You don't need to have a strong technical background to get value from this document. But having some sense of what good architecture looks like helps you know whether to push back on any of its choices. If something in the stack doesn't make sense for your project, trust your instincts and ask Claude to reconsider.

### 6.2 Highlights from the Nurturo Technical Document

Here's what came back for my app, so you know the kind of output to expect for yours:

**Mobile framework:** React Native with Expo (iOS and Android)

**Backend API:** NestJS (a Node.js framework), structured, maintainable for a solo dev

**Database:** PostgreSQL with Upstash Redis for caching; BullMQ for job queues

**Authentication:** Clerk, handles auth so you don't have to build it from scratch

**Email:** Resend, modern, affordable, solid free tier

**Hosting:** Railway, $20/month for pro, very developer-friendly

**Monitoring:** Sentry (free tier) and PostHog for analytics (1 million events/month free)

**AI integration:** OpenAI for the AI features, notably, even though Claude is doing the research and drafting, it recommended OpenAI for the AI features in the product. It chose what it thought was best for the job. That's what I want from a good prompt.

**Free tier summary:** Almost every service in the stack has a meaningful free tier. At the stage where you're building and testing, your infrastructure costs should be close to zero. Claude called that out explicitly in the document.

### 6.3 The Architecture Diagrams

One of the things I didn't fully anticipate: Claude also produced a text-based architectural diagram of the database schema, tables, relationships, key fields. Before we've written any code. That kind of early-stage architectural clarity is exactly why the planning phase exists.

This whole document is what you'd eventually hand to a developer or an agency and say: "Build this." It tells them what the thing is, what it's built on, how it's hosted, what it costs to run, and how to set it up. And you produced it in about 20 minutes, without having to be a software architect yourself.

ℹ️

If building it yourself feels like a stretch right now, this document is also perfectly usable as a brief for an agency or freelancer. Hand them this, the other product documents we're going to generate, and the market research, and you've given them everything they need to start. That's a completely valid path through this course.

### 6.4 Where It Lives

Claude writes the document directly into your Cowork folder. Not in the chat. Not in a clipboard you have to paste somewhere. In the folder. Go open Obsidian and you'll find a new file called `App - [AppName] - Technical.md`. Open it, let it render, and read through it.

This is why I keep telling you to use Obsidian, or at least a notes tool with a local file path. Claude is writing directly to your file system. That's not just convenient; it's building a habit of having your planning documents live with your project, not scattered across chat windows you'll never find again.

---

## 7\. Try It Yourself

### Exercise 1: Name Your App

**What to do:** Use the naming prompt structure from Section 2 to generate app name candidates with Claude. Answer its clarifying questions. Pick your top two candidates. Then do the three validation checks: Google search, domain availability, trademark check (USPTO for US, check your local equivalent for other jurisdictions).

**A nudge if you're stuck:** If no name feels right after two rounds with Claude, try giving it a specific constraint, like "give me names that are one or two syllables, easy to spell, and that work in English-speaking markets." Sometimes narrowing the brief helps.

**How you'll know it's working:** You have a name you can say out loud without cringing, the `.app` or `.com` domain is available, and nobody has a trademark on it.

### Exercise 2: Set Up Cowork and Run the Technical Document Prompt

**What to do:** Open Claude Desktop, go to the Cowork tab, select the folder where your research documents are saved. Copy the prompt from Section 5.2 of these notes, fill in the three placeholders, `{{product_name}}`, `{{monthly_budget}}`, and `{{team_size}}`then paste it into Cowork and run it.

**A nudge if you're stuck:** If Cowork can't see your research document, double-check the folder you selected. The file needs to be inside the selected folder, not in a subfolder. Move it if necessary.

**How you'll know it's working:** Claude will acknowledge finding your market research document before it starts building. You'll see it referencing the correct file name in its output. When it finishes, a new `App - [AppName] - Technical.md` file should appear in your folder.

### Exercise 3: Read and React to the Output

**What to do:** Open the technical document Claude produced. Read the executive summary and the stack section. Note any decisions you'd push back on, things that feel wrong for your project. If anything needs revisiting, go back to Cowork and ask Claude to reconsider specific choices with a reason.

**What this is practising:** Working with AI output critically, not just accepting the first draft, but knowing when to iterate.

---

## 8\. You Should Be Able to Do This Now

Here's what you can put together with what we just covered:

- Use Claude as a naming partner, generating candidates, evaluating them with your own judgment, and validating before committing
- Set up Claude's Cowork tab and connect it to a project folder
- Use a structured prompt to generate a full technical architecture document grounded in your market research

### Check Yourself

- \[ \] My app has a name, validated on domain availability and trademark
- \[ \] My project files are renamed consistently using that name
- \[ \] I've set up Cowork with the correct folder
- \[ \] I've run the technical document prompt and Claude produced the output
- \[ \] The technical document is saved in my Obsidian folder and I've read through it
- \[ \] I understand the basic shape of the stack Claude recommended (even if I can't explain every piece of it yet)

✅

If you're ticking those boxes, you're ready for the next lesson, where we generate the UX and branding document. Same process, different prompt, different output. The pattern is going to feel familiar very quickly.

### If Something's Not Working

⚠️

****Cowork can't find my research document**  
****What's happening:** Either the folder isn't selected, or the file is in a subfolder that Claude can't see at the top level.  
****How to fix it:** In Cowork, click the folder selector in the corner and confirm the path. Then open Finder (Mac) or Explorer (Windows) and make sure the research file is directly inside that folder, not nested two levels deep. Move it if needed, then reload Cowork.

⚠️

****Claude wrote the file but I can't find it in Obsidian**  
****What's happening:** Obsidian needs to be pointed at the same folder Claude wrote to, your vault root needs to include the path where the file was saved.  
****How to fix it:** In Obsidian, go to Settings → Files & Links and check your Vault path. It should include the folder you pointed Cowork at. Alternatively, just navigate to the file in Finder and drag it into the Obsidian window to open it.

⚠️

****The document Claude produced feels too generic or vague**  
****What's happening:** The research document may not have enough specificity for Claude to infer the right product, or the prompt wasn't personalised with the correct app name.  
****How to fix it:** Go back to Cowork and follow up: "The technical document you produced felt fairly generic. Can you revisit it with more specificity? The product is \[describe your product in 2 sentences\]." You can iterate on Cowork outputs just like a regular chat, the conversation is still live.

---

## The Short Version

Here's what I want you to walk away with:

- **Name your app before you generate any documents:** The name anchors your file naming, your prompts, and your identity as a product. Get it done and validate it before going further.
- **Cowork is not the same as a regular Claude chat:** It has file access. Use it for document generation. Use regular chat for conversation.
- **The technical document is your architecture blueprint:** Stack, hosting, cost projections, environment setup, all of it grounded in your research, produced before you write any code.
- **Claude makes real architectural decisions:** It doesn't just produce boilerplate. If the research is good, the document will reflect what your actual product needs. Read it critically and push back where needed.
- **What you can do now:** Generate a professional-grade technical overview for any product idea, in about 20 minutes, with no prior architecture experience required.

---

## Quick Reference

### Technical Document Prompt

The full prompt is in Section 5.2\. Fill in before running:

- `{{product_name}}`your app name (e.g. `Nurturo`)
- `{{monthly_budget}}`your infrastructure budget (e.g. `$500`)
- `{{team_size}}`how many people are building (e.g. `2-3 developers`)

### Naming Prompt Template

```
Based on the research and the sensitivity of what the name can imply, 
can you suggest names for my app? For context, here's a quote from 
a real user review I found: [paste a relevant review quote].

If you need any clarity before suggesting names, ask me first.

```

### Name Validation Checklist

```
1. Google search — is anyone prominent using this name?
2. Domain check — is .app or .com available? (Namecheap, Google Domains)
3. Trademark search — USPTO (us) or your local equivalent

```

### Cowork Setup Steps

```
1. Open Claude Desktop (not the browser version)
2. Click the Cowork tab at the top
3. Select folder → navigate to your project documents folder
4. Confirm your research file is visible in the sidebar
5. Paste your prompt and run

```

### File Naming Convention (What I Use)

```
[AppName] Market Research.md
[AppName] Market Review.md
App - [AppName] - Technical.md     ← produced this lesson
App - [AppName] - UX.md            ← next lesson
App - [AppName] - Stakeholder.md   ← coming up
App - [AppName] - GTM.md           ← coming up

```

---

## Resources

### Tools Used

- [Claude Desktop](https://claude.ai/download?ref=deletosh.com)required for Cowork tab and file writing
- [Obsidian](https://obsidian.md/?ref=deletosh.com)note storage and file management (any tool with a local path works)
- [Namecheap](https://namecheap.com/?ref=deletosh.com)domain availability checks
- [USPTO TESS](https://www.uspto.gov/trademarks/search?ref=deletosh.com)US trademark search (free)

### Technologies Claude Recommended for Nurturo

- [React Native + Expo](https://expo.dev/?ref=deletosh.com)cross-platform mobile framework
- [NestJS](https://nestjs.com/?ref=deletosh.com)Node.js backend framework
- [Railway](https://railway.app/?ref=deletosh.com)hosting platform
- [Clerk](https://clerk.com/?ref=deletosh.com)authentication
- [Resend](https://resend.com/?ref=deletosh.com)transactional email
- [PostHog](https://posthog.com/?ref=deletosh.com)product analytics (generous free tier)
- [Sentry](https://sentry.io/?ref=deletosh.com)error monitoring (free tier available)

---

## Questions I Get Asked

**Q: Do I have to use the stack Claude recommended?**

Not at all. Claude is recommending based on what it infers from your research. If you already know you want to build with a specific framework, because you know it, or because the team you're working with uses it, go with that. Update the technical document to reflect your actual choices. The document is yours. Claude's recommendations are a starting point, not a mandate.

**Q: I'm not technical. Do I actually need to understand the technical document?**

You need to understand it enough to be able to hand it to someone who is technical and have them say it makes sense. You don't need to know how to implement React Native, but you should understand that "mobile-first using React Native" means one codebase for both iOS and Android. Big-picture literacy is what you're going for. The module will get more technical as we move into coding, but by then you'll have a lot more context under your belt.

**Q: Can I just use the browser version of Claude for this?**

For the naming conversation, yes. For generating the technical document via Cowork, no. Cowork is only available in Claude Desktop. If you try to generate this in a regular chat by pasting your research document, you'll get a similar output, but it won't be saved to your folder automatically. You'll have to copy-paste it yourself. It's not a disaster, but it's more work and it breaks the workflow we're building toward.

**Q: How do I know I'm ready for the next lesson?**

The technical document is in your Obsidian folder, you've read through it, and you have a name you've validated. That's it. Move on.

---

## 💬 Stuck? Come Talk to Us

💡

If something's not clicking or you want to share what you've built, come find us in Discord.  
****The Foundry →** [****https://discord.gg/hT2TheKzZ**](https://discord.gg/hT2TheKzZ?ref=deletosh.com)  
Drop your question in the right channel. The community's growing and I check in there too.

---

## Glossary

**Cowork:** A tab in Claude Desktop that connects Claude to a folder on your computer, allowing it to read and write files directly. Not available in the browser version of Claude. *(first used this lesson, Module 2, Lesson 3)*

**React Native:** A framework for building mobile apps that run on both iOS and Android from a single codebase. Used with Expo for a more managed, developer-friendly setup. *(introduced this lesson, Module 2, Lesson 3)*

**Expo:** A toolset built on top of React Native that simplifies building, testing, and deploying mobile apps without needing to manage native iOS/Android build tools directly. *(introduced this lesson, Module 2, Lesson 3)*

**NestJS:** A Node.js framework for building backend APIs. Structured and opinionated, which is a good thing when you're building solo, because it makes the architecture more predictable. *(introduced this lesson, Module 2, Lesson 3)*

**Technical Document:** A planning document that describes the product's architecture, stack choices, infrastructure, security, API design, cost projections, and environment setup. Lives with the codebase. Does not contain any code itself. *(first produced this lesson, Module 2, Lesson 3)*

**Trademark:** A legal registration that gives exclusive rights to use a name or mark in commerce. Check before committing to a product name. In the US, search via USPTO TESS (free). *(introduced this lesson, Module 2, Lesson 3)*

**.app domain:** A top-level domain (`.app`) commonly used for software products and mobile apps. Managed by Google, HTTPS required by default. Generally more available and more relevant than `.com` for new apps. *(introduced this lesson, Module 2, Lesson 3)*
### Module 2, Lesson 2: Reviewing Your Market Research
URL: https://deletosh.com/courses/product-path/02-02-review-market-research/
Last updated: 2026-07-16T15:33:27.000Z
## How do you review AI generated market research?

You treat the AI output as a first draft, not the final answer, then pressure test it against reality. That means visiting competitor websites yourself, reading real app store reviews where actual customer pain lives, studying the biggest player in the space, and looking for the white space nobody is filling well.

The goal is to confirm or challenge your go or no-go signal with your own eyes, producing a human verified research document before you move into writing product docs.

**The short version: you treat AI generated research as a first draft, not the final answer, then pressure test it against reality by reading real app store reviews, studying the biggest player, and looking for the white space everyone is missing. That is how a go or no go signal becomes trustworthy. The full review pass is inside The Product Path.**

## Where Are We in the Research Phase?

We're on Module 2, Lesson 2\. Here's the trail so far:

- [Module 1, Lesson 1](https://deletosh.com/courses/build-what-ships/02-01-market-research/): What You'll Need, tools, accounts, all set up
- [Module 1, Lesson 2](https://deletosh.com/courses/build-what-ships/01-02-understanding-the-process/): Understanding the Process, the seven-step pipeline from research to shipped code
- [Module 2, Lesson 1](https://deletosh.com/courses/build-what-ships/02-01-market-research/): Market Research, running Claude's Deep Research to generate your market analysis

In this lesson, I'm picking up directly from the research document Claude produced in Module 2, Lesson 1\. We've got the AI's output, now I'm going to show you how I actually go through it, pressure-test it, and fill in the gaps Claude can't fill for you.

ℹ️

No corrections or updates to previous lessons. If you haven't done Module 2, Lesson 1 yet, do that first, this lesson won't make as much sense without a research document to work from.

---

## Before We Start

Here's what I'd expect you to have in place before this lesson:

**From previous lessons:**

- You should have your market research document from [Module 2, Lesson 1](https://deletosh.com/courses/build-what-ships/02-01-market-research/)Claude's Deep Research output, saved to Obsidian (or wherever you keep your notes)
- You understand what the seven-step pipeline is, this lesson is still in Step 1, the research phase, but we're doing the human half of it

**Tools / setup you'll need:**

- Your notes tool (Obsidian or whatever you're using), you'll be making notes in parallel as you review
- A browser, you'll be visiting competitor websites and app stores directly
- Access to iOS and/or Android app stores, for reading real reviews

**By the end of this lesson, you'll:**

- Know how to review and verify AI research output, not just accept it at face value
- Have spotted things in the market that Claude didn't catch
- Have confirmed (or challenged) your go/no-go signal with your own eyes
- Have a research document ready to carry into the documentation phase

---

## About This Lesson

**Duration:** \~17 minutes video + \~30,60 minutes for your own review pass  
**Skill Level:** Intermediate  
**What You'll Build:** An augmented, human-verified research document, your real foundation before we start writing product docs

The previous lesson was about using Claude to do the heavy lifting on research. This one is about not being lazy. The AI is fast and thorough, but it doesn't have your intuition. It doesn't feel the product. It doesn't know what makes you angry as a user. That's what this lesson is for.

---

## Watch the Lesson

---

ℹ️

****How I'd suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section. After that, this guide is your reference, you shouldn't need to rewatch to look something up.

---

## What We're Covering

Here's what I'm walking you through in this lesson:

- **Why you can't just trust the AI output**: what Claude gets right, what it misses, and why your own eyes matter
- **How to review competitor products properly**: websites, app stores, and the reviews that actually tell you what's happening
- **Reading app store reviews like a researcher**: where the real customer pain lives
- **Identifying your white space**: the gap in the market that nobody's filling well yet
- **Confirming your go/no-go signal**: using what you've found to make an honest call before you invest more

---

## 1\. Let's Set the Scene *(\~0:00)*

If you've done [Module 2, Lesson 1](https://deletosh.com/courses/build-what-ships/02-01-market-research/), you've got a research document sitting in Obsidian. Claude produced it. It probably looks impressive, structured, comprehensive, full of data points and competitor summaries.

Here's the thing: I don't just hand that to myself and move on. The AI did the first pass, but I still have to go and confirm it with my own eyes. This is the lesson where I show you how I do that.

For my app, a co-parenting expense and communication platform, I'm reviewing what Claude found and then going to the actual competitor websites and App Store listings myself. Pulling up reviews. Reading what real customers are saying. Noticing things that aren't in the report.

This is not optional. If you're serious about building something people will pay for, you have to invest yourself into the heads of your future customers. That takes more than reading a summary.

---

## 2\. The Core Idea

### 2.1 AI Research Is the First Draft, Not the Final Answer

Claude's Deep Research is genuinely impressive. It browses, synthesises, and structures information at a scale and speed you can't match manually. That's why we use it.

But there are things it can't do. It can't download an app and actually use it. It can't read a one-star review and feel the frustration. It can't notice that a competitor's branding inadvertently alienates the exact people they're trying to serve. Those things require a human being, which is you.

The way I think about it: Claude gives me the map. I still have to walk the territory.

ℹ️

This is the part of the process where your judgment and intuition become a real competitive advantage. Two founders can run the same Claude research prompt and get the same output. What they do with it next is where they diverge.

### 2.2 You're Not Reinventing the Research: You're Pressure-Testing It

This isn't about redoing what Claude already did. It's about three things:

1. **Confirming** what Claude said is actually true
2. **Catching** what Claude missed, the subtle stuff that only surfaces when you look with your own eyes
3. **Adding your own read**: what does this market feel like? What does the messaging tell you about who these products are really for?

You're not going deep on everything. You're spot-checking the important claims and then digging into the places that matter most for your specific angle.

### 2.3 How This Connects to Module 2, Lesson 1 - Market Research

In Module 2, Lesson 1, the output was the research document, a structured summary of the market. That document is the input to this lesson. You're not starting fresh; you're building on top of it.

By the end of this lesson, that document should have your notes on it. Things you confirmed, things you questioned, things you found that weren't in there. The more honest that document is, the better everything downstream will be, because your product docs, your specs, and your roadmap all trace back to this.

---

## 3\. Let Me Show You How It Works *(\~1:00)*

### 3.1 Set Up Your Review Session

Open two things side by side:

1. Your AI research document in Obsidian (or wherever you saved it)
2. A fresh note where you'll capture your own observations

💡

In Obsidian, you can drag a tab to split the view, put the Claude research on one side and your notes on the other. It makes the back-and-forth much easier during your review pass.

You're not going to read every word of the research linearly. You're looking for the key claims, particularly around competitors, and then going to verify them directly.

### 3.2 Start With the Biggest Player in Your Space

Claude should have told you who the dominant player in your market is. That's your first stop.

Go to their website. Look at:

- **What they're leading with**: what's on the homepage hero? What's the main promise?
- **What features they're pushing**: especially anything new or highlighted
- **How they're positioned**: premium? Accessible? Court-focused? Consumer?
- **What they're not talking about**: sometimes the most revealing thing is what a competitor isn't saying

For my app, the biggest player is OurFamilyWizard. They have nearly 80,000 ratings on iOS with a 4.5-star average. On Android it's 4.2 stars. On the surface, they look like people love them. But that's the surface.

### 3.3 Go Where the Real Reviews Live

App Store and Play Store ratings tell you one story. Third-party review platforms tell you another.

Claude flagged a site called Smart Customers (an app review aggregator) where OurFamilyWizard has a 1.3-star rating. That's a very different picture from their App Store 4.5\. I went and confirmed it, and yes, the reviews there are brutal. Complaints about customer service, things not working, pricing, data portability.

This is gold. This is your competitors' customers telling you exactly what they hate, and what you should build differently.

💡

When you're reading reviews, you're not just looking for complaints. You're listening for the language people use. The specific words and phrases they reach for when something frustrates them, that's your future marketing copy. (We'll come back to this when we get to the GTM phase.)

### 3.4 Read App Store Reviews Like a Researcher

Download the apps if you can. At minimum, go through the App Store or Play Store listing and read recent reviews, especially the 1- and 2-star ones.

When I was going through the SupportPay App Store reviews, I found something Claude hadn't caught. There was a review from a user saying that the name of a competing app, CoParenter, was actually traumatising her, because the word "coparent" was tied to painful memories. That's the kind of subtle thing that never makes it into a research summary, but it's important.

It tells me: branding matters enormously in this space. The words you choose carry weight for people who are often going through one of the hardest periods of their lives.

That's not a feature, it's a product philosophy. And I wouldn't have known it if I hadn't taken the time to read reviews myself.

ℹ️

This is what I mean by "investing yourself into the heads of your future customers." These are people who will be paying you money. Read what they write. Feel what they feel. It will change how you build.

### 3.5 Notice What Everyone's Doing: That's Your Constraint and Your Signal

As I went through competitor after competitor, one thing became obvious: they are all mobile apps. Not websites. Mobile apps first.

Claude's research didn't call this out directly, but it's critical. It tells me that if I want to play in this market, I need to build for mobile. The market has already told me the delivery format that works.

This is one of the underrated benefits of having established competitors in your space. They've already spent the money figuring out what format works. You don't have to guess.

---

## 4\. Finding Your White Space

White space is the gap in the market, the thing nobody is doing well, or at all. Your job in this review pass is to identify yours.

For my app, it became clear during the review:

- **Expense management** is the biggest pain point in the co-parenting space
- **Nobody is doing it well**: it's an afterthought for OurFamilyWizard, and the one app that was focused on it (UpClose) seems to have run into trouble since bumping their price
- **SupportPay** has the deepest expense feature but has terrible UX and poor traction despite $9.4 million in funding

That's my white space. A focused, well-designed expense tracking experience for co-parents, built mobile-first, with court credibility, and better UX than anything that exists right now.

🔥

Your white space should come from the intersection of three things: (1) a real pain that customers are complaining about, (2) an area where competitors are weak or absent, and (3) something you can actually build well. If you've got all three, you're in business.

### What If You Can't Find White Space?

If you've done a thorough review and you can't find a clear differentiation, stop.

Don't get emotionally attached to an idea that the market is telling you doesn't have a gap. Step back, go back to the research phase, and look at a different angle or a different market entirely. You have Claude now. Running another research pass costs you nothing except time, and it's much cheaper than building the wrong thing.

---

## 5\. Confirming Your Go / No-Go Signal

At the end of your review pass, you should be able to answer these questions honestly:

1. **Is the market real?** Are there established players making money? (If nobody's making money here, why not?)
2. **Is there a clear pain?** Are customers of existing products vocally frustrated about something?
3. **Is there a gap I can fill?** Is there a specific angle nobody is executing well?
4. **Do I have a believable path to customers?** Is there a channel or community that could reach my early users?
5. **Are the unit economics workable?** If I charge X, can I acquire a customer for less than X and make the business survive?

For my app, the answers were: yes, yes, yes, yes, and yes. In fact the unit economics work out to a 5,15x return on acquisition cost, meaning if I spend $8 to get a customer, I can make $40,$120 back over their lifetime. That's a business worth building.

If your answers are mostly yes, keep going. If you're getting a lot of maybes or nos, that's important data, take it seriously.

⚠️

****Don't skip the honest self-assessment.** The purpose of all this research is to tell you the truth before you spend six months building something. A difficult truth now is a gift. An avoided truth now is a disaster later.

---

## 6\. Watch Out For These

⚠️

****Taking the AI output at face value.**  
Here's why this happens: the research looks comprehensive, so it feels complete.  
The way I avoid it: I always go to at least the top 2,3 competitors directly, with my own eyes, before closing out the research phase.  
If you've already done this: add a "manual review" section to your notes and fill it in now, it's not too late.

⚠️

****Only reading the positive reviews.**  
Here's why this happens: it feels more encouraging.  
The way I avoid it: I go straight to the 1- and 2-star reviews first. That's where the real product feedback lives.  
If you've already done this: go back and read the negative reviews now. Make a note of the top 3 complaints that come up repeatedly.

⚠️

****Falling in love with your idea instead of the evidence.**  
Here's why this happens: you've invested time, and the idea feels good.  
The way I avoid it: I treat the go/no-go question as a real question with a real answer, not a formality I'm going through to confirm what I already decided.  
If you're hitting this: be honest with yourself. If the evidence is thin, acknowledge that and either find better evidence or revisit the idea.

---

## 7\. Practice

### Exercise 1: Do Your Own Review Pass

**What to do:** Open your Claude research document from Module 2, Lesson 1\. Create a fresh note for your own observations. Then visit each of the top 3 competitors Claude identified, their website, their App Store / Play Store listing, and at least one third-party review source. Write down what you confirm, what you question, and what Claude missed.

**A nudge if you're stuck:** Start with the biggest player. Just go to their website and spend 10 minutes reading it as a potential customer. What does it promise? What does it not mention? Does it feel trustworthy? Write that down.

**How you'll know it's working:** Your notes will have things in them that aren't in the Claude research. Observations, impressions, and at least one thing Claude didn't flag. That's the human layer added.

### Exercise 2: Find Your White Space

**What to do:** Based on your review, write a single paragraph, in plain language, describing the gap you're going to fill. Not a mission statement, not a pitch. Just: "I noticed that no one is doing X well, and customers are clearly frustrated about it, and I think I can do it better by doing Y."

**What this is practising:** Clarity of positioning. If you can't write it in a paragraph, you don't understand it well enough yet. That's okay, that's what this exercise surfaces.

---

## 8\. You Should Be Able to Do This Now

Here's what you can do with what we just covered:

- Run a structured review of competitor products using websites, app stores, and third-party reviews
- Identify the difference between what competitors claim and what their customers actually experience
- Find the white space in your market, the gap nobody's filling well
- Make an honest go/no-go call on your idea

### Check Yourself

- I've reviewed at least 2,3 competitors directly (not just via the Claude summary)
- I've read real customer reviews, especially the negative ones
- I've found at least one thing Claude's research didn't flag
- I can describe my white space in a single paragraph
- I've made an honest go/no-go call on my idea

✅

If you're ticking those boxes, you're done with the research phase. The next lesson is where we start turning everything we know into actual product documents. That's where it gets interesting.

### If Something's Not Working

⚠️

****I can't find clear white space in my market.**  
****What's happening:** Either the market is very well-served (possible, but rare), or you're looking at it too broadly.  
****How to fix it:** Narrow your lens. Instead of "project management for teams," look at "project management for solo freelancers" or "for design agencies." The white space often lives in a niche, not the whole market. Go back to Claude and ask it to help you find an under-served segment.

---

## The Short Version

Here's what I want you to walk away with:

- **Claude's research is the first draft, not the final answer:** It's thorough and fast, but it needs a human pass to be complete.
- **The real customer insight is in the reviews:** Not the star ratings, the actual written reviews, especially the negative ones. That's where you find what to build.
- **White space is your competitive advantage:** Find the thing nobody's doing well and make that your focus. That's the game plan.
- **Make an honest go/no-go call:** The whole point of the research phase is to tell you the truth before you commit. Don't skip it.

---

## Resources

### Tools Used

- [Obsidian](https://obsidian.md/?ref=deletosh.com)note-taking and knowledge management, used for storing and reviewing the research output
- [OurFamilyWizard](https://ourfamilywizard.com/?ref=deletosh.com)co-parenting app (competitor reference used in the lesson)
- [SupportPay](https://supportpay.com/?ref=deletosh.com)child support and expense tracking app (competitor reference used in the lesson)
- [Apple App Store](https://apps.apple.com/?ref=deletosh.com)for reviewing app ratings and reading customer reviews
- [Google Play Store](https://play.google.com/?ref=deletosh.com)same

---

## Questions I Get Asked

**Q: Do I really need to download competitor apps, or is reading their website enough?**

If it's a mobile app and your app is also going to be mobile, yes, you should download it and actually use it. Even 10 minutes of hands-on time tells you things a website never will. You'll notice the UX friction, the onboarding flow, where it feels clunky. That's exactly what you want to know before you design your own.

**Q: What if Claude's research and my review say different things?**

Trust your own eyes. You went to the actual source, Claude synthesised from whatever it could access. If there's a conflict, note it in your research document and go with what you confirmed directly. The manual review exists precisely to catch these gaps.

**Q: How long should I spend on the review pass?**

Roughly 30,60 minutes for most markets. Don't let it become a week of analysis paralysis. You're looking for confirmation on the key claims and your white space, not an academic dissertation. Set a timer, go through your top 3 competitors, read the reviews, write your notes, and move on.

**Q: How do I know I'm ready for the next lesson?**

If you've ticked the checklist above and you can write your white space in a single paragraph, you're ready. Module 2, Lesson 3 is where we start writing the actual product documents. Everything you've gathered in the last two lessons feeds directly into that.

---

## 💬 Stuck? Come Talk to Us

💡

If something's not clicking or you want to share what you've built, come find us in Discord.  
****Build What Ships community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community's active and I check in there too.

---

## Glossary

**White space:** The gap in a market that nobody is filling well, or at all. Your white space is where you have a credible advantage over existing players. *(introduced this lesson, Module 2, Lesson 2)*

**Go/no-go signal:** The honest verdict at the end of your research phase, is this market worth investing in, given everything you've found? *(introduced in* [*Module 2, Lesson 1*](https://deletosh.com/courses/build-what-ships/02-01-market-research/)*, confirmed this lesson)*

**MVP (Minimum Viable Product):** The smallest version of your product that delivers real value to real customers. Not everything you want to build, the least you can build that still works. *(introduced this lesson, Module 2, Lesson 2)*

**Unit economics:** The math of your business at the individual customer level, what it costs to acquire one customer, and what that customer is worth to you over time. If you spend $8 to acquire a customer and they pay you $15/month for a year, your unit economics are very healthy. *(introduced this lesson, Module 2, Lesson 2)*

**Third-party review platforms:** Sites like Smart Customers, Trustpilot, or G2 where users leave reviews independently of the product's own App Store listing. Often more candid and critical than official store reviews. *(introduced this lesson, Module 2, Lesson 2)*
### Module 2, Lesson 1: Market Research
URL: https://deletosh.com/courses/product-path/02-01-market-research/
Last updated: 2026-07-16T15:33:25.000Z
## How do you do market research with Claude?

You use Claude Desktop's Deep Research feature, driven by structured prompts, to size the market, map competitors, and surface real demand before committing to a build. A useful trick is to have Claude ask you clarifying questions first, which makes the output dramatically sharper.

Claude produces a thorough first draft in about fifteen to twenty minutes, grounded in real data rather than gut feel, and you save it into your notes system to feed the documentation phase that follows.

**The short version: you drive market research with structured prompts that size the market, map competitors, and surface real demand before you commit to a build. Claude produces a first draft fast, and your job is to pressure test it. The full prompt sequence and review method live in The Product Path.**

Where We Are in the Course

We're on Module 2, Lesson 1\. This is where the over-the-shoulder work begins, no more slides or theory. We're at the computer.

Here's what we've covered so far:

- [Module 1, Lesson 1](https://deletosh.com/courses/build-what-ships/01-01-what-youll-need/): What You'll Need, tools installed, accounts set up, ready to go
- [Module 1, Lesson 2](https://deletosh.com/courses/build-what-ships/01-02-understanding-the-process/): Understanding the Process, the seven-step pipeline from research to shipping code, and why each step exists

In this lesson, I'm picking up from the pipeline overview and kicking off Step 1, Market Research. This is the first piece of real work we do before touching any product design whatsoever.

ℹ️

No corrections or updates to previous lessons. You're in good shape, carry on.

---

## Before We Start

Here's what I'd expect you to have under your belt before this lesson:

**From previous lessons:**

- You should understand the seven-step pipeline we mapped in Module 1, Lesson 2, this lesson is Step 1 of that pipeline
- You know why we do research before documentation, and documentation before specs, we covered the "why" in Module 1, Lesson 2

**Tools / setup you'll need:**

- Claude Desktop (the local desktop app, not claude.ai in your browser)
- A Claude Pro plan (or higher), the free tier won't give you access to Deep Research
- An idea you want to validate, you're welcome to follow along with mine, but I'd encourage you to use your own

**By the end of this lesson, you'll:**

- Know how to use Claude's Deep Research feature to validate a market in under 20 minutes
- Understand what to look for in the research output, market size, competition, pain points, and the go/no-go signal
- Have a research document saved into your notes system, ready to feed into the next phase

---

## What Is This Lesson About?

**Duration:** \~26 minutes video + \~20 minutes for your own research run  
**Skill Level:** Intermediate  
**What You'll Build:** A structured market research report saved to your Obsidian vault (or notes tool of your choice)

The whole point of this lesson is to show you that what used to take a team of consultants weeks, understanding a market, mapping competitors, validating a pain point, you can now do in about 15 minutes on your own. And we're doing it with real data, not gut feel.

---

## Watch the Lesson

---

ℹ️

****How I'd suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section, pausing the video at the timestamps I've noted. After that, this guide is your reference, you shouldn't need to rewatch to look something up.

---

## What We're Covering

Here's what I'm walking you through in this lesson and why it matters if you're trying to ship real things:

- **Why most people skip research (and why that's a mistake)**I'll show you exactly what the old way looks like and why Claude changes the equation
- **Claude Deep Research vs. standard chat**: these are genuinely different things, and knowing which mode you're in matters
- **Running the research session**: the prompt structure I use, including the "ask me questions first" trick that makes the output dramatically better
- **Reading the output**: what to look for: market size, competitive landscape, pain points, unit economics, and the go/no-go verdict
- **Saving the research with the Filesystem MCP**Claude writes the output directly into your Obsidian vault, ready for the next phase

---

## 1\. Let's Set the Scene *(\~0:00)*

Our goal in this section is simple: validate whether your idea is worth building before you invest any real time in it.

Before tools like Claude, you'd spend days doing this manually, clicking through a bunch of links, reading articles, pulling together spreadsheets, synthesising findings. Most people just skipped it. They'd have an idea, convince themselves it was good, and start building. And that's precisely how you end up six months in with something nobody wants.

Here's what I love about where we are now. Using Claude's Deep Research, you can get a structured, data-grounded market analysis, competitors, market size, pain points, monetisation models, go/no-go recommendation, in under 20 minutes. That changes everything. There's no excuse anymore to skip this step.

The idea I'm working with in this course is a co-parenting expense management app, a tool for separated or divorced parents to track and split shared costs for their kids. I came across this as an interesting problem. I'm not personally a co-parent, which is exactly why I want the data before I trust my intuition.

Use your own idea. That's the point of this exercise.

---

## 2\. Claude Desktop vs. Claude.ai: Get This Right First

Before we run a single prompt, let's make sure you're set up correctly. This is a gotcha that trips people up.

### 2.1 Why Claude Desktop Matters Here

You need the Claude Desktop app, not the browser version at claude.ai. They look similar, but they're not the same. The desktop version is what allows Claude to use MCP extensions, including the Filesystem extension we'll use later to save the research document directly to your computer.

Here's how you know you have the right version installed:

- At the top of the app, you should see **Chat** and **Cowork** in the menu bar
- Open the sidebar, go all the way down to your name, click it, and go to **Settings**
- In Settings, you should see a **Desktop App** section, specifically a category called something like "Assistant Extensions"
- If you see that, you're good

If you're on the web version, the Desktop App section won't be there. That's your signal to go download the correct one.

⚠️

****Common mistake: using claude.ai in the browser**  
If you run the research from the browser version, everything in this section will still work, but you won't be able to save the file to your Obsidian vault at the end, and the MCP features later in the course won't work at all. Make the switch now so you don't have to backtrack.

### 2.2 The Model to Use

As of when I recorded this, the latest version is **Claude Sonnet 4.6**. Stick with that. Don't switch to Opus 4.6, it's significantly more expensive in terms of token usage, and for a long research session, you'll burn through your limit before the research is even done.

---

## 3\. Deep Research vs. Standard Chat *(\~2:00)*

This is a teaching point I want you to really get, because it changes how you use Claude for this kind of work.

### 3.1 What Standard Chat Does

A normal Claude chat can answer questions, summarise things you paste in, brainstorm, write, it's drawing on what it already knows, and it can do a basic web search when you enable it. That's useful for a lot of things, but it's not what we want here.

### 3.2 What Deep Research Actually Does

Deep Research is different. When you enable it, Claude doesn't just look something up, it actively browses, reads multiple sources, cross-references findings, and synthesises everything into a structured output. Think of it like asking a very capable analyst to go away and do a proper literature review rather than just answering off the top of their head.

It's similar to tools like Perplexity if you've used those, but built into Claude with the same context window and reasoning capabilities you already know.

### 3.3 How to Enable It

In a new Claude Desktop chat, click the **plus (+) icon** inside the text input area. You'll see options, you want to enable **Research**, not just web search. Make sure the Research mode icon is active before you send your prompt. If it's not there, you're in standard chat mode and you'll get a very different (and much less useful) result.

🚨

****Check this before you hit Enter**  
You need to see the Research mode icon in the input area before sending. If you don't, stop, you'll be running a standard chat and won't get the deep market analysis we need. This is a common miss.

---

## 4\. Running the Research Session *(\~2:30)*

### 4.1 The Prompt Structure I Use

Here's the structure of the prompt I ran for the co-parenting app idea. Adapt this for your own idea, the prompt is in your course resources:

```
I have an idea for an app: [describe your idea in 2-3 sentences].

Please do deep research on the best way to approach this towards getting to a go / no-go decision for this app.

Important: before you start the research, ask me all the clarifying questions you need. Don't begin the research until I've answered them.

```

That last bit, asking for clarifying questions first, is the most important part of the prompt. Here's why.

### 4.2 The "Ask Me Questions First" Trick

When I ran this, Claude came back with a set of clarifying questions before starting any research:

- **What's your target market?** (US only? English-speaking globally? Worldwide?)
- **What's your intent with this research?** (Validate the market? Understand competitors? Decide on pricing?)
- **Who are you?** (Technical co-founder, solo founder with budget, first-time builder, etc.)

These questions aren't just Claude being thorough, they're genuinely useful for you too. Answering them forces you to articulate things you might have left fuzzy. And the more specific and honest you are in your answers, the more targeted and useful the research output will be.

For the co-parenting app, my answers were:

- **Target market:** English-speaking markets globally
- **Intent:** Validate if the market exists and is worth entering, understand competitors, find the best monetisation model, give me a full go or no-go
- **Who am I:** Technical, with some budget to invest, starting from scratch

Be specific. If you say you're non-technical when you're actually technical-ish, the research will be calibrated differently. Claude adjusts its depth and framing based on your answers.

💡

Use your own idea here, not mine. The co-parenting app is my example to demo the process. The value of this exercise is in running it for something you're actually thinking about building. If you follow along with my idea instead of yours, you'll have done the practice but missed the point.

### 4.3 What Happens While It Researches

Once you've answered the questions, Claude will confirm what it's going to do, then go off and do the research. This takes time, for me it was about 14 minutes. That's normal. Walk away, get a coffee, come back.

You'll see it actively working in the background, it tells you what it's browsing, what it's finding. That's the agentic piece in action: it's not just querying a database, it's actually browsing and synthesising like a person would.

---

## 5\. Reading the Output *(\~6:45)*

After about 14 minutes, I had a full market research report. Here's how I walked through it, and what you should be looking for in yours.

### 5.1 Market Size and Opportunity

The first section to look at is what the total addressable market looks like. For the co-parenting app:

- Around 34 million separated parents across five English-speaking markets (US, UK, Canada, Australia, New Zealand)
- Less than 3% are using any dedicated app for this, huge untapped market
- The total market opportunity is in the range of $4 billion

You don't need to obsess over the exact numbers, they're estimates. What you're looking for is whether this is a meaningful size and whether it's underpenetrated. A large market with low existing adoption is a much better signal than a saturated one.

### 5.2 Competitive Landscape

Claude laid out the existing players, what they charge, roughly how many users they have, their key strengths, and, this is the useful bit, their key weaknesses.

For this market, two competitors were doing over $10 million in annual recurring revenue. That's a great signal. It tells you the market is real and people are paying. If the field were empty *and* the market were supposedly worth $4 billion, that would actually be a red flag.

One thing that jumped out: a competitor called OurFamilyWizard made a significant pricing change in early 2026 that's likely to push users out the door. That's an active acquisition window, a moment where people are already annoyed and looking for alternatives. That kind of intel would have taken a consultant weeks to surface.

Claude also identified where the market is crowded (communication features, shared calendars) versus where there's genuine white space. The white space here? Expense-only management. An app that had owned that niche, called Onward, shut down a few years back and nobody has filled the gap since. No existing competitor offers receipt scanning or auto-categorisation. That's the gap.

### 5.3 Validated Pain Points

Any idea you validate has to have a pain point that's real, not assumed. Claude's research pulled actual evidence of the problem:

- Co-parents tracking expenses manually through spreadsheets, Venmo, Zelle, text messages, fragmented and unverifiable
- Court-ordered payment disputes where one parent has no proof they covered a cost
- Apps that charge $50 for 24-hour access to your own financial records (genuinely wild)
- Rigid expense-splitting that doesn't support anything other than 50/50

These aren't things I assumed. These are documented frustrations from real users in the market. That's what "validated" means.

### 5.4 Monetisation Model

Claude recommended a three-tier model, free basic, a mid tier at around $120/year, and a premium tier with AI features. It also laid out unit economics: cost to acquire a customer, lifetime value per family, the LTV:CAC ratio.

You don't need to take Claude's monetisation recommendation as gospel. Use your professional judgment. But having a data-grounded starting point, rather than guessing, is exactly the point.

One thing that stood out to me: if the app ever got mandated by a family court in any US state, customer acquisition cost drops to zero. The court mandates it. That's an unusual GTM angle worth holding on to.

### 5.5 The Verdict

At the end of the report, Claude gave a clear recommendation. For this idea: **very strong go**.

The reasoning: large market, low penetration, validated pain points, two competitors proving people will pay, an active market disruption moment (the OurFamilyWizard pricing change), and a clear gap in the expense-only space.

That's what you're looking for at the end of your own report. Not a maybe, a clear signal, with evidence.

ℹ️

****If the verdict is no-go, that's still a win.**  
The whole point of this step is to find out before you build. A no-go that saves you six months of work on the wrong thing is one of the most valuable outcomes this process can produce. Don't be attached to a go verdict. Be attached to an accurate one.

---

## 6\. Saving the Research to Obsidian *(\~9:30)*

Once the research is done, you need to save it somewhere you can reference it later. Everything we produce from this point forward, the PRD, the GTM document, the user journey, the specs, is going to be grounded in this research. Don't let it live only in the Claude chat window.

### 6.1 Setting Up the Filesystem Extension

Here's how this works. In Claude Desktop, go to Settings → Desktop App → Assistant Extensions. You should see an extension called **Filesystem**: if it's not installed, click Browse and install it. It's usually near the top of the list.

Once it's installed, click **Configure** and add the file path to your notes folder. For me, that's my Obsidian vault saved inside Dropbox. Whatever your path is, add it here. Claude needs to know where it's allowed to write files on your computer.

⚠️

****Claude Desktop only**  
The Filesystem extension, and this entire file-writing step, only works in Claude Desktop. If you're on the web version, you'll need to manually copy the research output into your notes. Make the switch before this step.

### 6.2 Saving the File with a Prompt

Go back to the chat where your research lives and type something like this:

```
Using the filesystem tool, save the research to [your file path]

```

Replace the path with the actual path to your notes folder, the same one you configured in the extension settings.

Claude will then:

1. Look at your file system
2. Navigate to the path you specified
3. Write a structured Markdown file with all seven sections from the research

This is the agents piece I keep mentioning. Claude isn't just answering a question, it's actually doing something: navigating your file system and writing a file. That's why the Desktop app and the Filesystem extension are required.

### 6.3 What You End Up With

After Claude saves the file, go open Obsidian (or whatever notes tool you're using). You'll find a new Markdown document with the full research output, structured, readable, with sections you can collapse and reference. This becomes the foundation everything else is built on.

I save mine inside my Dropbox so it's accessible and backed up. You can save yours wherever makes sense.

---

## 7\. Try It Yourself

### Exercise 1: Run Your Own Research Session

**What to do:** Open Claude Desktop, enable Deep Research, and run the market research prompt against an idea you have. Answer Claude's clarifying questions honestly and specifically. Let it run.

**A nudge if you're stuck:** If you don't have an idea yet, pick something you've complained about recently. A problem you've encountered yourself is often the best starting point, you already understand the pain.

**How you'll know it's working:** Claude will ask clarifying questions before it starts. If it just jumps straight into research without asking anything, check that Research mode is actually enabled, standard chat doesn't ask.

### Exercise 2: Read the Output and Identify the Key Signals

**What to do:** Once the research comes back, find and note these five things before moving on: (1) total addressable market size, (2) top two or three competitors and what they charge, (3) the biggest gap or white space in the market, (4) the core validated pain point, (5) the go/no-go verdict.

**What this is practising:** Reading research critically, not just scanning it, but actually extracting what matters for a build decision.

### Exercise 3: Save the Research to Your Notes

**What to do:** Use the Filesystem extension to have Claude write the research into your Obsidian vault (or your notes folder). Confirm the file is there and opens correctly.

**How you'll know it's working:** The file will appear in Obsidian, render as structured Markdown, and have all the sections from the research output.

---

## 8\. You Should Be Able to Build This Now

Here's what you can put together with what we just covered:

- A market research report for any idea, grounded in real data, completed in under 20 minutes
- A competitive landscape overview that would have taken a team to produce manually

### Check Yourself

- I ran Deep Research on my own idea (not just watched Dele run it on his)
- I know the difference between standard chat and Deep Research mode in Claude
- I can identify the five key things to look for in a research output
- My research document is saved in Obsidian (or my notes tool) and ready to reference
- I have a clear go or no-go signal for my idea

✅

If you're ticking those boxes, you're ready for Module 2, Lesson 2, Documentation. That's where we take this research report and use it to generate the three foundational product documents: the Research Summary, the PRD, and the GTM.

### If Something's Not Working

⚠️

****Research mode icon isn't showing up**  
****What's happening:** You're in a standard Claude chat, not Deep Research mode.  
****How to fix it:** Click the plus (+) icon inside the text input area and look for the Research option. Enable it before sending your prompt. If the plus icon isn't there either, check that you're in Claude Desktop and not the browser version.

⚠️

****Claude won't save the file to Obsidian**  
****What's happening:** Either the Filesystem extension isn't installed, or the path you configured is wrong.  
****How to fix it:** Go to Settings → Desktop App → Assistant Extensions. Check the Filesystem extension is installed and that the configured path actually matches where your Obsidian vault lives. Copy-paste the path directly, don't type it by hand.

---

## The Short Version

Here's what I want you to walk away with:

- **Deep Research is not the same as a Claude chat:** It actively browses and synthesises. Enable it deliberately before every research session.
- **Ask for clarifying questions first:** That one line in the prompt makes the research dramatically more targeted. Don't skip it.
- **You're looking for five things:** Market size, competitive landscape, white space, validated pain points, and the go/no-go verdict.
- **Save everything:** The research document is the foundation. Module 2, Lesson 2 doesn't work without it.
- **What you can do now:** Validate any market idea in under 20 minutes with data you can actually trust.

---

## Quick Reference

### The Research Prompt Template

```
I have an idea for an app: [describe your idea in 2–3 sentences].

Please do deep research on the best way to approach this towards 
getting to a go / no-go decision for this app.

Important: before you start the research, ask me all the clarifying 
questions you need. Don't begin the research until I've answered them.

```

### Clarifying Questions Claude Will Ask (expect these)

```
1. Target market — geography, language, specifics
2. Intent — what decision is this research informing?
3. Who are you — founder background, technical level, resources

```

### Five Things to Find in the Output

```
1. Total addressable market size
2. Top competitors + what they charge
3. The gap or white space
4. Validated pain points (with evidence)
5. Go / no-go verdict + rationale

```

### Enabling Deep Research

```
In the chat input → click (+) → enable Research mode
Look for the Research icon before hitting Enter

```

---

## Resources

### Tools Used

- [Claude Desktop](https://claude.ai/download?ref=deletosh.com)the desktop app, required for this lesson
- [Obsidian](https://obsidian.md/?ref=deletosh.com)the notes app used for saving the research output (any Markdown-compatible tool works)

---

## Questions I Get Asked

**Q: Can I use Perplexity instead of Claude Deep Research?**

You can, and the output will be reasonably similar for the research phase. The reason I use Claude here is that we're going to stay in Claude Desktop for the next several phases, feeding the research into documentation, then into specs, so it makes sense to keep everything in the same tool. If you run the research in Perplexity, you'll need to paste the output manually into Claude for the next steps.

**Q: The research came back as a no-go. What do I do?**

Honestly? Be glad. That's the point of this step, to find out before you spend months building something. Go back to the idea stage, pick something else, and run the research again. A no-go in 15 minutes is infinitely better than a no-go after six months of work.

**Q: My research is taking longer than 14 minutes. Is that normal?**

Yes, research time varies depending on how complex the market is and how busy Claude's servers are at that moment. Give it up to 20,25 minutes before worrying. If it times out or errors, just run it again.

**Q: Do I need to use Obsidian specifically?**

No. Obsidian is my choice, it saves as Markdown, it's offline, and it works well with the Filesystem MCP. But any notes tool with a local file path will work. Notion local files, a plain folder on your desktop, whatever. The key is that the path you give Claude actually exists and is writable.

**Q: How do I know I'm ready for the next lesson?**

If you've run the research on your own idea, you can identify the five key outputs in the report, and your research document is saved and accessible, you're ready for Module 2, Lesson 2.

---

## 💬 Stuck? Come Talk to Us

💡

If something's not clicking or you want to share what you've built, come find us in Discord.  
****Build What Ships community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community's active and I check in there too.

---

## Glossary

**Deep Research:** A specific mode in Claude that goes beyond standard chat, it actively browses multiple sources, synthesises findings, and produces a structured report. Different from a regular Claude conversation with web search enabled. *(first used in* [*Module 2, Lesson 1*](https://deletosh.com/courses/build-what-ships/01-02-understanding-the-process/)*Market Research)*

**Total Addressable Market (TAM):** The full potential revenue available if you captured every possible customer in your target market. Used as a ceiling to understand whether a market is worth entering, not a target you'll realistically hit. *(first came up in* [*Module 2, Lesson 1*](https://deletosh.com/courses/build-what-ships/01-02-understanding-the-process/)*)*

**LTV:CAC Ratio:** Lifetime Value to Customer Acquisition Cost. A unit economics metric, how much revenue a customer generates over their lifetime compared to what it costs to acquire them. You generally want this at 3:1 or better. *(first came up in* [*Module 2, Lesson 1*](https://deletosh.com/courses/build-what-ships/01-02-understanding-the-process/)*)*

**Filesystem Extension (MCP):** A Claude Desktop extension that lets Claude read from and write to your local file system. This is how Claude saves the research document directly into Obsidian without you having to copy-paste anything. *(first used in Module 2, Lesson 1; we go much deeper on MCP in Module 2, Lesson 3, User Journey Mapping)*

**Go/No-Go:** The binary decision this research phase is designed to produce, is this idea worth investing further time and money in, or not? *(introduced in* [*Module 1, Lesson 2*](https://deletosh.com/courses/build-what-ships/01-02-understanding-the-process/)*; first applied in* [*Module 2, Lesson 1*](https://deletosh.com/courses/build-what-ships/01-02-understanding-the-process/)*)*
### Module 1, Lesson 2: Understanding the Process
URL: https://deletosh.com/courses/product-path/01-02-understanding-the-process/
Last updated: 2026-07-16T15:33:23.000Z
## What is the seven step process The Product Path follows?

The process runs in a deliberate order: market research, documentation, user journey mapping, feature requirements, project planning, then build. Each phase produces the exact input the next phase needs, so by the time you write code the hard decisions are already made.

Skipping straight to code feels faster with AI, but speed to code is not speed to ship; front loading the thinking is what keeps the build moving in the right direction.

**Here is the process this course follows, and it runs in a deliberate order: market research, documentation, user journey mapping, feature requirements, project planning, then build. Each phase produces the exact input the next phase needs, so by the time you code the hard decisions are already made.**

Where We Are in the Course

We're on Module 1, Lesson 2\. Here's where we've been:

- [**Module 1, Lesson 1: What You'll Need**](https://deletosh.com/courses/build-what-ships/01-01-what-youll-need/): we covered who this course is for, what you should already know, and got all your tools installed and ready.

In this lesson, I'm not touching any tools yet. This one is all mindset and process, I want to show you the full pipeline we're going to work through before we start running. Trust me, this is worth the few minutes it takes.

ℹ️

No corrections to Module 1, Lesson 1 to flag. We're picking up right where we left off.

---

## Before We Start

**From previous lessons:**

- You should have all your tools installed and accounts set up from [Module 1, Lesson 1](https://deletosh.com/courses/build-what-ships/01-01-what-youll-need/)Claude Pro, Figma (desktop), YouTrack, your code editor, and GitHub.

**Tools / setup you'll need:**

- Nothing to open for this lesson. It's conceptual, no live demo, no tools. Just us talking through the approach.

**By the end of this lesson, you'll:**

- Understand why jumping straight to code is a trap, even (especially) with AI
- Know the full seven-step pipeline we're using throughout this course
- See how each phase feeds directly into the next
- Have a mental model for why we front-load the thinking

---

## What Is This Lesson About?

**Duration:** \~9 minutes video + no hands-on practice required  
**Skill Level:** Beginner  
**What You'll Build:** Nothing yet, but you'll have a clear map of everything we're going to build together.

This lesson exists because I've seen too many people, smart, motivated people, blow up their projects before they've really started. AI has made it feel like you can skip the planning. You can't. I want to explain exactly why, and show you the system we're using instead.

---

## Watch the Lesson

---

ℹ️

****How I'd suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section. This one's short, but dense. After that, this guide is your reference, you shouldn't need to rewatch to look something up.

---

## What We're Covering

Here's what I'm walking you through in this lesson:

- **Why speed to code is a trap**: and why AI makes this worse, not better
- **The cooking analogy**: a mental model for how I think about this process
- **The seven-step pipeline**: the full sequence we're working through in this course, from market research to shipping code
- **Why the phases are in this order**: each one sets up the next, and skipping steps costs you later

---

## 1\. Let's Set the Scene *(\~0:00)*

You've got your tools installed. You're ready to go. And yeah, you're probably itching to open up Claude and start building something.

I get it. I've been there.

But before we do that, I want to spend a bit of time talking about why the *process* matters, and why you want to slow down, take a breath, and understand why we're approaching this the way we are.

Because there's a big problem with just jumping in. Whether you're opening Claude, Cursor, or whatever tool someone on Twitter told you to use, jumping straight to code creates more problems than it solves. And in this lesson, I want to show you exactly why.

---

## 2\. The Core Idea

### 2.1 Speed to Code ≠ Speed to Ship

Here's the thing most people don't say out loud: AI has made it very, very fast to build the *wrong* things.

You can sit down, write a prompt, and have something that looks fantastic running in minutes. That feels like progress. But if you haven't done any thinking upfront, if you don't know *why* you're building it, *who* it's for, or *what* problem it actually solves, then you're just building fast in the wrong direction.

Speed to code does not equal speed to shipping something people actually use.

And this matters more now, not less, because AI has removed the friction that used to slow people down and *force* them to think. You used to have to plan a bit just to write the code. Now you don't. So you have to make the choice to plan yourself.

⚠️

Rework is expensive. If you've done a bunch of AI-assisted building without upfront thinking, going back to fix structural problems later costs significantly more than doing the thinking first. The later in the process you catch a problem, the more expensive it is to fix.

### 2.2 The Cooking Analogy

I use cooking analogies a lot, fair warning. Here's one that I think nails this perfectly.

If you're going to make a good meal, you don't just walk into the kitchen and start throwing things into a pot hoping it turns out okay. You'll end up with something awful. What every good chef does is *prep their ingredients first*. Get everything ready. Understand what you're making. *Then* you start cooking.

That's exactly what we're doing here.

AI doesn't help us skip our thinking, it helps us reproduce things faster once we've done the thinking. The thinking still has to happen. We're just doing it first, where it's cheap, instead of later, where it's painful.

### 2.3 The "Vibe Coding" Trap

You're here because you want to build something meaningful. Not "slop", not another thing that got half-assembled in an afternoon because someone said you could make money with a prompt. You want to build something that actually ships and that people actually use.

The people who end up with apps that matter plan like product managers and build like founders. That's what this course teaches you to do.

---

## 3\. The Pipeline *(\~4:07)*

Okay, enough of the why. Here's the what.

We're going through **seven distinct steps** in this course. Not because I want to make your life complicated, but because each one feeds directly into the next. Skip one, and the thing downstream wobbles.

Here's the full pipeline:

---

### Step 1: Market Research

Every good founder does this first. You have an idea, great. Every idea sounds good in your own head. But does anyone actually care? Will anyone pay for this?

This is where we figure out: should we build this at all? Where's our angle? Where's the opportunity? What's already out there, and what gap can we fill?

ℹ️

This is where most people skip, and it's why so much of what gets built is junk. We're not skipping it.

---

### Step 2: Documentation

Once the research is done, we document what we found. We're going to produce a research summary, a PRD (product requirements document), and a go-to-market summary, all grounded in real data from the research, not assumptions.

This matters even if you're building solo. If you ever need to explain your product to an investor, a co-founder, or a new team member, having this written down is invaluable. And it keeps *you* honest about what you're building and why.

---

### Step 3: User Journey Mapping

Now we put on our product design hat for a bit. Before we write a single spec, we map out what the journey of a user actually looks like, from the moment they first hit the product through to when they get value from it.

We'll use FigJam for this (which is why you need the Figma desktop app, more on that when we get there). This is also where you'll get your first look at something I'll be using a lot: model context protocol, or MCP. Claude will be writing directly into FigJam for us.

---

### Step 4: Feature Requirements & RICE Scoring

Now we get specific about *what* we're building. We write user stories, score them using the RICE framework (Reach, Impact, Confidence, Effort), and prioritise which features to tackle first.

This is a well-established product management approach, and it's not as complicated as it sounds. When you know the framework, you know exactly what questions to ask the AI, and let it do the heavy lifting on the scoring. That's the pattern you'll see throughout this course.

---

### Step 5: Implementation Roadmap

Once we know what to build and in what order, we turn that into a phased delivery plan. This is how engineering teams work every day, batches of work, done step by step, delivered incrementally.

This isn't about slowing you down. It's about making sure that when you're building, you always know what "done" looks like for each piece. That's what makes you able to actually ship.

---

### Step 6: Project Planning in YouTrack

We take everything we've built, the research, the docs, the specs, the roadmap, and we structure it into a project management board. Epics, stories, acceptance criteria, testing criteria.

This is where it all becomes a proper backlog that you (or anyone you're working with) can actually execute against. And it's what sets us up for the coding phase.

---

### Step 7: Coding the Project

Now we build. Issue by issue, story by story. Claude Code does the writing, you're the QA. You know what "done" looks like for each issue because you defined it in Step 6\. So your job is to walk through what got built, test it against the criteria, and confirm it's right before moving on.

This is why this isn't a beginner course. You need enough background to know what good looks like, because you're the one who decides if it ships.

---

## 4\. Why This Order Matters

These steps aren't arbitrary. Each one is the input for the next:

- Research → informs Documentation
- Documentation → informs the User Journey
- User Journey → informs Feature Requirements
- Feature Requirements → informs the Implementation Roadmap
- Roadmap → populates the Project Board
- Project Board → drives the Coding phase

If you skip or rush any of these, the downstream steps get weaker. And by the time you're coding, you're guessing. We don't want to be guessing.

🔥

We're doing the hard work upfront because it's **cheaper* there. Reworking something in a planning doc costs you an hour. Reworking it in production code, especially AI-assisted code you didn't fully write yourself, costs you a lot more.

---

## 5\. The Goal

When we follow this process, here's what it gives you:

You plan like a product manager. You build like a founder. You ship like you mean it.

Not another half-finished side project. Not another thing that runs on localhost and never sees the real world. Something that gets out the door, makes sense to real users, and you can actually stand behind.

That's what this pipeline is built to produce.

---

## The Short Version

Here's what I want you to take from this lesson:

- **Speed to code ≠ speed to ship.** AI has made it fast to build the wrong things. Planning upfront is how you avoid that.
- **Prep before you cook.** Every phase we go through is an ingredient. We prep it all before we start coding.
- **The seven steps are sequential for a reason.** Each one feeds the next. Don't skip ahead.
- **What you can do now:** You know the full map. When we start Module 2, you'll know exactly where we are in the process and why.

---

## Quick Reference

### The Seven-Step Pipeline

```
1. Market Research        — validate the idea before you invest in it
2. Documentation          — turn research into foundational product docs
3. User Journey Mapping   — map the user experience before writing specs
4. Feature Requirements   — write user stories, score with RICE, prioritise
5. Implementation Roadmap — phase the work into a delivery plan
6. Project Planning       — build the board in YouTrack, ready to execute
7. Coding                 — build issue by issue, you're the QA

```

### Key Mental Models

- **Speed to code ≠ speed to ship**AI makes it fast to build wrong things
- **Prep before you cook**: front-load your thinking, not your code
- **Each phase feeds the next**: the output of one step is the input of the next

---

## Resources

### Frameworks & Tools Referenced

- **RICE Scoring**Reach, Impact, Confidence, Effort, product prioritisation framework *(we'll go deep on this in Module 3)*
- [FigJam](https://www.figma.com/figjam/?ref=deletosh.com)used for user journey mapping in Module 2, Lesson 3
- [YouTrack](https://www.jetbrains.com/youtrack/?ref=deletosh.com)project board we set up in later Module 3

---

## Questions I Get Asked

**Q: Do I really need to do all seven steps? Can't I just start with a rough idea and iterate?**

I hear this one all the time. You *can* skip steps, plenty of people do. But the reason we're here is to build something that actually ships and matters. The research and planning phases are precisely what separates things that ship from things that stay on localhost forever. The investment upfront is small compared to the rework you avoid later.

**Q: This feels like a lot of process for a solo founder. Is this really necessary?**

It scales down fine. You're not writing hundred-page PRDs, we're using AI to do the heavy lifting on all of this. What we're doing is making sure you think through the right questions before you start building. Even solo, that discipline pays off. Especially solo, actually, because there's no one else to catch your blind spots.

**Q: How do I know I'm ready for the next lesson?**

If you understand the seven steps and why they're in that order, you're good. Module 2, Lesson 1 is where we get into Market Research, the first step in the pipeline. That's where the over-the-shoulder work begins.

---

## 💬 Stuck? Come Talk to Us

💡

If something's not clicking or you want to share what you've built, come find us in Discord.  
****Build What Ships community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community's active and I check in there too.

---

## Glossary

**RICE Scoring:** A product prioritisation framework, stands for Reach, Impact, Confidence, and Effort. Used to score features against each other so you can make data-driven decisions about what to build first. *(we go deep on this in Module 3, Lesson 6, Feature Requirements & Implementation Roadmap)*

**MCP (Model Context Protocol):** A way of extending Claude's capabilities so it can interact directly with other tools, like writing into FigJam or your project repo. *(first used in Module 2, Lesson 3, User Journey Mapping)*

**User Story:** A way of writing a feature requirement from the user's perspective, "As a \[type of user\], I want to \[do something\] so that \[I get this outcome\]." *(introduced in Module 3, Lesson 6)*

**PRD (Product Requirements Document):** A foundational document that describes what the product is, who it's for, and what it needs to do. *(we produce this in Module 2, Lesson 2, Documentation)*

**Vibe coding:** Building an app by prompting an AI without any upfront planning or thinking, going purely on instinct and iteration. Fast, but usually produces things that don't ship or don't matter.
### Module 2, Lesson 0: Module Intro, Research & Strategy
URL: https://deletosh.com/courses/product-path/02-00-module-intro/
Last updated: 2026-07-16T15:33:22.000Z
## What is Module 2 of The Product Path about?

Module 2 is the research and strategy phase, where you replace gut feeling with structured market research so your idea is validated before a single spec exists.

By the end you have five documents grounded in real data: a market research report, a technical overview, a UX document, a stakeholder summary, and a go-to-market plan. It ends on a genuine go or no-go checkpoint, so if the idea has no market you find out now instead of six months into building.

**Here is what Module 2 is really about: this is where planning gets real, where you replace gut feeling with actual market research so the thing you build is validated before a single spec exists. The strategy work here becomes the input for every document and feature that follows. See how it connects across the full pipeline in The Product Path.**

## Before We Start

This is a short module intro, no tools, no setup needed. Just watch it and understand what's coming.

---

**By the end of this lesson, you'll:**

- Know exactly what Module 2 covers and why it's ordered the way it is
- Understand what five documents you'll have by the time this module is done
- Know what "done" looks like before we go any further

## About This Lesson

**Duration:** \~2 minutes video  
**Skill Level:** Beginner  
**What You'll Build:** Nothing yet, this is orientation

This is the module intro. Short, focused, and deliberate. I use these intros to make sure you know what you're walking into before you're in it, so nothing surprises you mid-lesson.

---

## Watch the Lesson

---

ℹ️

****How I'd suggest going through this:** Watch it in one go, it's two minutes. Then read the breakdown below so you know exactly what's coming in the lessons ahead.

---

## What Does This Module Cover?

Here's what Module 2 is all about:

- **Market Research**Using Claude's Deep Research to validate whether your idea has a market before you build a single thing
- **Four core documents**Technical overview, UX document, stakeholder summary, and a go-to-market plan, all generated from the research
- **A real go/no-go checkpoint**By the end, you'll know whether your idea is worth building, and if it isn't, you'll know now instead of six months from now

---

## 1\. This Is Where Things Get Real *(\~0:00)*

In Module 1, we talked about *why* you plan before you build. That was the mindset half. This module is where we actually do something about it.

The first thing we tackle is market research, and I don't mean Googling around for ten minutes or asking your friends if they'd use your app. I mean structured, data-grounded research that tells you whether a real market exists for what you're thinking about building.

---

## 2\. The Core Idea

### 2.1 Real Research, Not Gut Feeling

I've seen people skip this step more times than I can count, including myself, early on. You've got an idea, it feels good, you want to build. That energy is valuable. But if you channel it into building before you've validated anything, you're gambling.

The question I want you to be able to answer by the end of this module isn't "is this a good idea?", that's too vague. It's: **who's already in this market, what are they charging, where are they falling short, and what gap does your idea actually fill?**

That's the difference between building something that ships and makes money, and building something that ends up sitting on GitHub with three stars.

### 2.2 How This Connects to Module 1

In Module 1, Lesson 2 I walked through the full process pipeline, research feeds docs, docs feed specs, specs feed tasks, tasks feed code. This module is the first phase: research and the documents it generates. Everything we produce here carries forward. Nothing from this point is throwaway work.

---

## 3\. What You'll Walk Away With

By the time Module 2 is done, you'll have five documents:

1. **Market Research Report**: the raw findings from Claude's Deep Research
2. **Technical Overview**: what you're building and how it fits together technically
3. **UX Document**: how the product should look and feel for your users
4. **Stakeholder Summary**: the version you'd share with an investor or co-founder
5. **Go-to-Market Plan**: how you'll position it and get paying customers

All five grounded in real data. All five written before you've typed a line of code.

🔥

I used to spend weeks and a lot of money getting to this point, researching, hiring people to write briefs, going back and forth. Now this takes a few hours with a Claude subscription and the right prompts. That's what I'm showing you in this module.

---

## 4\. The Real Stakes

Here's the thing I want you to hold onto going into this module: **if your idea doesn't survive the research phase, that's a win.**

I know that sounds backwards. But finding out your idea has no market, or that someone's already doing it better than you could, now, in a few hours, is infinitely better than finding out six months later after you've built the whole thing.

The research phase is your filter. Let it do its job.

---

## The Short Version

Here's what I want you to take from this intro before we dive in:

- **Module 2 is the research and strategy phase**: this is where you validate before you build
- **We generate five documents**: market research, technical overview, UX doc, stakeholder summary, and GTM plan
- **This is your foundation**: every decision you make in Modules 3 and 4 traces back to what we produce here

---

## 💬 Stuck? Come Talk to Us

💡

Questions about what's coming up, or just want to talk through your idea before you start? Come find us in Discord.  
****Build What Ships community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community's active and I check in there too.

---

## Glossary

**Deep Research:** Claude's research mode that actively browses and synthesises sources from across the internet, not just a chat response. Think of it like systematic Googling, but done at scale with structured output. *(we use this properly in Module 2, Lesson 1 - Market Research)*

**Go/No-Go Checkpoint:** A deliberate decision point where you assess whether to continue building based on real evidence. The market research report is your first one. *(concept introduced in Module 1, Lesson 2 - Understanding the Process)*
### Module 1, Lesson 1: What You'll Need
URL: https://deletosh.com/courses/product-path/01-01-what-youll-need/
Last updated: 2026-07-16T15:33:20.000Z
## What do you need to start The Product Path course?

You need three things: an idea worth testing, a Claude account (Pro or higher), and a willingness to plan before you code. No heavy tooling or prior setup is required at the start; the tools get introduced and installed step by step as the course needs them.

It assumes basic coding fundamentals, meaning you can read and write some HTML, CSS, and a little JavaScript, but not that you are a former software engineer.

**Here is what you actually need before starting, and it is not much: an idea worth testing, a Claude account, and a willingness to plan before you code. No heavy tooling or prior setup is required yet. The rest gets introduced step by step across The Product Path.**

## Where Are We in the Course Right Now?

This is the very beginning, Module 1, Lesson 1\. Welcome. Glad you're here.

There are no prerequisites to reference yet. We're starting from scratch. But before we dive into building anything, I want to get us on the same page about who this course is for, what you should already know, and what tools you're going to need. Getting this stuff sorted now saves a lot of frustration later.

ℹ️

This is also the lesson I'll be updating if anything changes, new tools, updated requirements, that kind of thing. Check back here if something feels off.

---

## Before We Start

There's nothing from a previous lesson to have under your belt, this is lesson one. But there *is* assumed knowledge coming in, and I want to be upfront about that.

**Tools / setup you'll need for this lesson:**

- No tools required yet, this lesson is orientation. Tool setup starts here and gets used from Lesson 2 onward.

**By the end of this lesson, you'll:**

- Know exactly who this course is (and isn't) for
- Understand what background knowledge I'm assuming you already have
- Have a clear list of tools to install before we move forward
- Have a mental map of the entire process we're going to follow together

---

## About This Lesson

**Duration:** \~8 minutes video  
**Skill Level:** Beginner  
**What You'll Build:** Nothing yet, this is setup and orientation

This is the "before we start" lesson. I'm laying out who I built this for, what I expect you to know coming in, and what tools you need on your machine before the real work begins. If you skip this and jump ahead, that's your call, but don't say I didn't warn you when something doesn't make sense later.

---

## Watch the Lesson

---

ℹ️

****How I'd suggest going through this:** Watch the video first without stopping, just get the big picture. Then come back here and work through the guide section by section. This one's short, but the checklist at the end matters. Make sure you've got everything ticked before you move on.

---

## What We're Covering

Here's what I'm walking you through in this lesson:

- **Who this course is for**I'm making assumptions about you, and I'd rather be honest about them upfront
- **What you should already know**: the baseline knowledge I need you to have so we can skip the basics
- **The tools you need**: exactly what to install and why
- **The process we're going to follow**: a bird's-eye view of everything from idea to shipped product

---

## 1\. Let's Set the Scene *(\~0:00)*

This course is over-the-shoulder style. That means I'm going to be building a real product throughout, and you're going to be right there with me. You can follow along and build the same thing I'm building, or bring your own idea and use my process to build that. Either works. Honestly, bringing your own problem to solve is probably the best way to get real value from this.

But before we get anywhere near code, I want to make some things clear about what kind of course this is, and what it isn't.

---

## 2\. Who Is This For?

### 2.1 The Person I'm Building This For

I'm imagining you're probably a solo founder. Maybe you're technical, maybe you're a technical co-founder working alongside someone non-technical. Maybe you're just someone with a side project you want to turn into something real. This is for you.

What I'm *not* imagining is that you're completely new to this. This isn't a "I've never written a line of code in my life" course. It's also not a "just throw prompts at AI and watch a product appear" course. There are plenty of those out there. This one is different, we're going to go through some fundamentals that most people skip, and those fundamentals are what actually get you to something you can sell.

### 2.2 What I'm Assuming You Already Know

Here's what I need you to have coming in:

**Basic coding fundamentals.** You can read and write some HTML, some CSS, and at least a little JavaScript. You don't need to be a former software engineer. But "I don't know what coding is" is too far back for where we're starting.

**Git and GitHub flow.** You've used Git before. You know roughly how commits, pushes, and repos work. We're going to be using it heavily throughout this course, so if you're rusty, spend a couple of hours getting the basics back before we go further.

**Prompting with an AI assistant.** You've used Claude, ChatGPT, Cursor, or something similar. You know how to write a prompt. You don't need to be an expert, just not a complete beginner.

**Basic understanding of the software development cycle.** When I say "sprint," you know what that means. You understand that some things are front-end and some things are back-end. You have a rough sense of what an API is and how apps are generally structured. Again, not deep expertise, just enough to follow along without getting lost on the terminology.

ℹ️

I'm not listing all this to scare you off. I'm listing it so we're on the same page. If any of these feel shaky, a few hours of focused reading or watching can get you there. I'll include some resources at the bottom of these notes to help.

---

## 3\. The Tools You'll Need *(\~4:41)*

Here's exactly what you need to have installed and ready before we go any further.

### Claude Pro: Desktop App

Get the desktop version, not the web version. We're going to be using Claude heavily for research, documentation, and user journey mapping. The desktop app is what makes the MCP integrations work, and MCP is how Claude talks to your other tools.

If you're not on Pro, I'd say spend the money. We're going to be using it a lot throughout this course and it's worth it.

💡

Don't worry about what MCP is yet, we'll cover that properly when we get to it. For now, just make sure you've got Claude Pro desktop installed.

### Figma: Desktop App

The free version is fine. We're going to be using Figma for user flow diagrams, not full UI design. The reason I need the desktop version (not the browser version) is that the Figma MCP only works with the local desktop install. More on that when we get there.

### YouTrack: Free Tier

This is our project management tool. I chose YouTrack because the free tier is genuinely generous and it supports MCP, which is how we'll be automating issue creation later in the course. If you want to use Linear instead, that also supports MCP and the principles are the same, but I'll be demonstrating everything in YouTrack, so if you want to follow along exactly, use that.

### Code Editor: WebStorm or VS Code

I use WebStorm from JetBrains. I love it, it's my tool of choice and I'll be running Claude Code inside the WebStorm terminal throughout the build phase. That said, if you're already comfortable in VS Code, stick with it. A lot of what I show will transfer over. Where it doesn't, I'll try to flag it.

⚠️

If you want to follow my steps exactly during the coding phase, use WebStorm. Some of what I show in the JetBrains MCP integration may not have a direct VS Code equivalent.

### GitHub

You need a GitHub account. It's free. This is our central hub, where all our code lives and where Claude will be pushing work as we go. If you don't have one, go set it up now.

---

## 4\. The Process We're Going to Follow *(\~6:51)*

Here's the big picture, the full process we're going to work through together. I want you to see this now so nothing feels like it comes out of nowhere later.

1. **Market Research**Start with an idea and validate it properly before touching a single line of code
2. **Documentation**Turn the research into foundational product documents (PRD, GTM, and more)
3. **User Journey Mapping**Design the full onboarding flow visually before writing specs
4. **Feature Requirements**Write structured, testable requirements that live inside your codebase
5. **Project Planning**Translate the specs into dev-ready issues on your YouTrack board
6. **Build**Finally, actually write the code, issue by issue, with Claude Code doing the heavy lifting
7. **Sales & Marketing**How to actually get people to use what you've built

Most people skip straight to step 6\. Some skip to step 4\. I've seen people waste weeks going down dead ends because they started coding before they knew if anyone wanted the thing. We're not doing that.

🔥

The whole point of this process is that each step feeds the next. Your research informs your docs. Your docs inform your user journey. Your user journey informs your specs. Your specs inform your tasks. Your tasks drive the code. Skip a step and the whole chain gets weaker. Do them in order.

---

## 5\. Try It Yourself

### Before Moving On: Install Your Tools

**What to do:** Go through the tools list above and install everything that isn't already on your machine.

- Claude Pro, Desktop app downloaded and signed in
- Figma, Desktop app installed (free tier is fine)
- YouTrack, Account created, free tier set up
- Code editor, WebStorm or VS Code installed and ready
- GitHub, Account created, Git installed locally

**How you'll know it's working:** You can open all five tools without hitting a paywall or setup screen.

---

## 6\. You Should Be Able to Answer These Now

- I know what background knowledge this course assumes I have
- I have all five tools installed and ready
- I can describe the 7-step process we're going to follow
- I understand why this course starts with research instead of code

✅

If you've got your tools installed and you can tick those boxes, you're ready for Module 1, Lesson 2\. Let's go.

---

## The Short Version

Here's what I want you to walk away with:

- **This isn't a vibe coding course.** We're going to do this properly, research first, code last.
- **You need some basics coming in.** HTML/CSS/JS fundamentals, Git, prompting, and a rough understanding of how software gets built.
- **Five tools to install:** Claude Pro (desktop), Figma (desktop), YouTrack, WebStorm or VS Code, and GitHub.
- **Seven steps, in order.** Research → Docs → User journey → Specs → Planning → Build → Market. We follow the chain.

---

## Quick Reference

### Tools List

| Tool       | Version / Tier      | Why We Need It                                               |
| ---------- | ------------------- | ------------------------------------------------------------ |
| Claude Pro | Desktop app         | Research, docs, user journey mapping — plus MCP integrations |
| Figma      | Desktop, free tier  | User flow diagrams via Figma MCP                             |
| YouTrack   | Free tier           | Project management and Agile board via YouTrack MCP          |
| WebStorm   | Any current version | Code editor + terminal for Claude Code (VS Code also works)  |
| GitHub     | Free                | Code repository — central hub for the whole project          |

### The 7-Step Process

```
1. Market Research
2. Documentation (PRD, GTM, etc.)
3. User Journey Mapping
4. Feature Requirements + RICE Scoring
5. Project Planning in YouTrack
6. Build (issue by issue with Claude Code)
7. Sales & Marketing

```

---

## Resources

### Catch Up on the Basics

- [Git Handbook](https://guides.github.com/introduction/git-handbook/?ref=deletosh.com)GitHub's own intro, takes about an hour
- [Anthropic Prompt Engineering Guide](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview?ref=deletosh.com)Good foundation for prompting Claude effectively
- [MDN Web Docs, Getting Started with the Web](https://developer.mozilla.org/en-US/docs/Learn/Getting%5Fstarted%5Fwith%5Fthe%5Fweb?ref=deletosh.com)HTML/CSS/JS basics if you need a refresher

### Tools

- [Claude](https://claude.ai/?ref=deletosh.com)Get Claude Pro, then download the desktop app
- [Figma Desktop](https://www.figma.com/downloads/?ref=deletosh.com)Make sure you download the desktop version, not just use the browser
- [YouTrack](https://www.jetbrains.com/youtrack/?ref=deletosh.com)Free tier available
- [WebStorm](https://www.jetbrains.com/webstorm/?ref=deletosh.com)Free tier available
- [GitHub](https://github.com/?ref=deletosh.com)Free

---

## Questions I Get Asked

**Q: Do I really need WebStorm, or can I use VS Code?**

VS Code works. I use WebStorm because it's what I know and love. The JetBrains MCP integration is tighter in my workflow, and some things I show during the build phase are specific to WebStorm. If you want to follow along exactly, use WebStorm. If you're already deep in VS Code, you'll be able to adapt most of it.

**Q: Can I use a different project management tool instead of YouTrack?**

Yes, as long as it supports MCP. Linear is a good alternative. The concepts are the same, Epics, Stories, acceptance criteria, the lot. I'll be demoing in YouTrack, so the UI will look different, but the principles transfer.

**Q: I'm not very strong on JavaScript, am I going to struggle?**

Honestly, as long as you can read it and have a rough sense of what's happening, you'll be okay. Claude Code will be writing most of the code. What I need from you is the ability to look at what Claude produces and have a gut feeling for whether something looks wrong. You don't need to be able to write it from scratch.

**Q: How do I know I'm ready for the next lesson?**

Your tools are installed and your checklist is ticked. That's it. Let's move.

---

## 💬 Stuck? Come Talk to Us

💡

If something's not clicking or you want to share what you've built, come find us in Discord.  
****Build What Ships community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop your question in the right channel. The community's active and I check in there too.

---

## Glossary

**MCP (Model Context Protocol):** The protocol that lets Claude talk to external tools, Figma, YouTrack, your code editor, and more. We'll cover this properly when we get to it. For now, just know it's why the desktop version of Claude matters. *(we go deeper on this starting in Module 2)*

**PRD (Product Requirements Document):** A document that defines what the product is, who it's for, and what it needs to do. One of the foundational docs we'll generate in Module 2\. *(first built in Module 2, Lesson 2)*

**GTM (Go-to-Market Document):** A document that defines how the product will be positioned and launched. Also generated in Module 2\. *(first built in Module 2, Lesson 2)*

**RICE Scoring:** A prioritisation framework, Reach, Impact, Confidence, Effort. We use it to rank features objectively rather than going with gut feel. *(covered in Module 3)*

**Sprint:** A fixed time period (usually 1,2 weeks) during which a specific set of work gets done. Standard Agile terminology. *(used throughout Module 3 and Module 4)*
### Module 1, Lesson 0: Module Intro
URL: https://deletosh.com/courses/product-path/01-00-module-intro/
Last updated: 2026-07-16T15:33:19.000Z
## Why plan before building when AI makes coding so fast?

Because AI has made it cheap to build the wrong thing in a single afternoon, so planning upfront is now protective rather than old fashioned.

Front loading research, documentation, and specs means the hard decisions are settled before you write code, and every phase produces the input the next phase needs. The trade off is slowing down briefly at the start so the rest of the build moves fast and in the right direction.

**Here is why planning still matters even when AI makes building this fast: AI has made it cheaper to build the wrong thing in a single afternoon, so planning upfront is now protective rather than old fashioned. This module maps the full pipeline, market research through to a shipped product, so every phase feeds the next one. Want the whole system in order? The Product Path course.**

## Before We Start

No prerequisites. No setup required yet. Just you and about 90 seconds of me setting the tone for how this whole course works.

**By the end of this lesson, you'll:**

- Understand why planning before building matters more than ever, not less, now that AI is fast
- Know the full process we're following together throughout the course and why it's in this order
- Be ready to move into Module 1, Lesson 1 with the right mindset

---

## About This Lesson

**Duration:** \~2 minutes video  
**Skill Level:** Beginner  
**What This Is:** A short orientation before we get into the tools and process.

I recorded this intro last, after building the whole thing, so I could be specific about exactly where we're going and why. It's not fluff. It's 90 seconds that'll save you from making the most common mistake I see people make with AI-assisted development.

---

## Watch the Lesson

---

ℹ️

****How I'd suggest going through this:** Watch the video first, it's short. Then read through this guide. There's no code to write yet, no tools to open. This one is about mindset before we get into mechanics.

---

## What Will This Module Cover?

- **The trap AI has created**: why being able to build fast doesn't mean building fast is the right call
- **The process we're following**: a map of every phase in this course and how they connect
- **Why the order matters**: each phase produces the input for the next one

---

## 1\. The Problem I Keep Seeing

Here's what I've watched happen over and over again.

Someone has a good idea. They open Cursor, or Claude, or Codex, whatever they're using. They write a prompt, something gets generated, it looks incredible, and then three weeks later they've built something nobody wants. No clear path forward. They have to start over.

That's not a tool problem. That's a process problem.

AI hasn't made planning optional. It's made skipping it more expensive than ever. You can now build the wrong thing in a single afternoon. That's not progress, that's a faster way to waste your time.

🚨

****The AI trap:** The faster and easier a tool makes building, the more tempting it is to skip planning. Resist it. Speed to code is not the same as speed to the right thing.

---

## 2\. What This Module Is For

So in Module 1, I'm going to slow us down, just for a moment. Not to be precious about it. Just enough so that everything we do from here moves fast and in the right direction.

Think of it like cooking. You don't walk into the kitchen and start throwing things in the pot hoping for the best. A good chef preps before they cook. Every ingredient is ready before the heat goes on.

That's what this module is. It's our prep phase.

We'll cover:

1. What you need to have in place before you start (Module 1, Lesson 1)
2. The full process we're following and why it's ordered the way it is (Module 1, Lesson 2)

And then we build.

---

## 3\. The Full Process: Your Map

Here's the complete picture of what we're doing in this course, in order:

| Phase                    | What We Do                                          |
| ------------------------ | --------------------------------------------------- |
| **Market Research**      | Validate the market before investing in the product |
| **Documentation**        | Turn the research into structured product docs      |
| **User Journey Mapping** | Map the full user flow before writing a single spec |
| **Feature Requirements** | Write testable specs, score and prioritise features |
| **Project Planning**     | Translate specs into a dev-ready Agile board        |
| **Build**                | Code issue by issue until the board is clear        |

Every phase produces output that feeds directly into the next one. That's not accidental, it's the whole architecture of the process.

ℹ️

By the time we get to the coding phase, we're not figuring out what to build. That decision has already been made, and made well. The coding phase is just execution.

---

## The Short Version

Here's what I want you to carry into the rest of this module:

- **AI makes it faster to build the wrong thing.** Planning upfront isn't old-fashioned, it's protective.
- **Every phase feeds the next.** This process isn't arbitrary. Each output is the input for what follows.
- **We slow down here so we can move fast everywhere else.** That's the trade-off, and it's worth it.

---

## 💬 Stuck? Come Talk to Us

💡

Questions, thoughts, or just want to introduce yourself before we dive in, come find us in Discord.  
****Build What Ships community →** [****https://discord.gg/RFXRf9yg**](https://discord.gg/RFXRf9yg?ref=deletosh.com)  
Drop a message in the intro channel. I check in there too.

---

## Glossary

**Vibe coding:** Jumping straight into building with AI without a plan, prompting until something looks right and hoping for the best. Fast to start, expensive to fix. *(first came up in Module 1, Lesson 0, Module Intro)*
### Enterprise AI — How to Use Copilot at Work (Without Getting Fired)
URL: https://deletosh.com/writing/microsoft-copilot-work-enterprise-ai/
Last updated: 2026-07-13T10:16:46.000Z
*Part 5 of 5 in the series: AI at Work — A Professional's Field Guide*

---

**How do you use Microsoft Copilot at work without breaking compliance?** Set it up correctly (save the file to OneDrive or SharePoint, turn on Auto-Save, and confirm a Microsoft 365 Premium Copilot license), keep confidential client and personnel data out of Teams meetings you do not host, and verify every calculation before it goes anywhere official. Used that way, Copilot cuts hours off Excel, Outlook, and Word work while your judgment stays the quality control. The Pipeline keeps these enterprise AI workflows current.

So far in this series, we've focused on what you can do on your personal device with public AI tools.

Now let's talk about what you can do at work.

Microsoft Copilot is embedded in the Office 365 tools you already use every day — Excel, Outlook, Teams, Word. If your firm has a Microsoft 365 Premium license, you already have access.

But it doesn't just work automatically. There are infrastructure requirements. Security policies. And the right way to use it — so you're adding professional value, not creating compliance problems.

This article covers all of it.

---

## What do you need to set up before Copilot in Excel will work?

Copilot in Excel won't work if you get these wrong.

**1\. File must be saved in OneDrive or SharePoint**  
Local files don't work. Period. If you open a file from your desktop or a local drive and wonder why Copilot isn't responding — this is why. Save to OneDrive first.

**2\. Auto-Save must be turned on**  
The toggle is in the top-left corner of Excel. When it's blue, it's on. Copilot needs continuous cloud sync to maintain context. Without it, nothing works.

**3\. Copilot must be licensed**  
You need Microsoft 365 Premium — not basic Microsoft 365\. If your firm has enterprise licensing that includes Copilot, you're covered. Look for the Copilot icon in the top-right corner of the Excel ribbon. If it's there, you're good.

🚨

****Mac users:** Copilot in Excel has limited functionality on Mac. If you're serious about using it for production work, use your Windows work computer. If you need it on a Mac for personal reasons, Parallels Desktop running Windows apps is the workaround — but it adds complexity. Use your work computer for this.

---

## The Budget Workflow (A Real Example)

Here's the use case we worked through in our sessions: preparing an annual team budget.

The challenge: a massive department-wide Excel file. You need to extract your five direct reports' data, build a 2026 forecast, create a variance analysis, and produce something presentable to leadership.

Traditional approach: 3-4 hours of manual filtering, formula-building, and formatting.

With Copilot: about 55 minutes.

Here's the workflow:

---

**Phase 1: Setup (5 minutes)**

Save the file to OneDrive. Enable Auto-Save. Verify the Copilot icon is visible in the ribbon. Right-click any cell and select "Copilot" to open the panel.

---

**Phase 2: Data Extraction (10 minutes)**

```
I need to extract budget data for my team members:
- [Employee 1]
- [Employee 2]
- [Employee 3]
- [Employee 4]
- [Employee 5]

From the current data, create a new sheet that includes:
- All compensation components (base salary, bonus, benefits)
- 2025 actual spending by category
- Department overhead allocations

Name the new sheet: "My Team - 2025 Actuals"

```

Review what Copilot produces. Verify all employees are captured. Click "Add to new sheet."

---

**Phase 3: 2026 Forecast (10 minutes)**

```
Using the data in "My Team - 2025 Actuals," create a 2026 
budget forecast with these assumptions:
- 3% cost-of-living adjustment on base salaries
- 5% merit increase pool
- Benefits costs at 4% trend rate
- Maintain current overhead allocation methodology

Show 2025 actual and 2026 forecast side-by-side.
Use formulas so I can adjust assumptions in one place.

Add to a new sheet: "2026 Budget Forecast"

```

💡

****Request formulas, not hard-coded values.** If you tell Copilot to build formulas tied to assumption cells, you can change the COLA percentage once and the whole model updates. This is the difference between a one-time output and a reusable tool.

---

**Phase 4: Variance Analysis (10 minutes)**

```
Compare "My Team - 2025 Actuals" and "2026 Budget Forecast."
Show:
- Dollar variances by employee and category
- Percentage variances
- Total team budget impact
- Conditional formatting: highlight variances over 10% or $10,000

Add to a new sheet: "Variance Analysis"

```

---

**Phase 5: Visual Dashboard (10 minutes)**

```
Create a budget dashboard for leadership presentation:
1. Column chart: 2025 actuals vs. 2026 forecast by employee
2. Pie chart: 2026 budget breakdown by category
3. Bar chart: year-over-year % changes by employee

Add to a new sheet: "Budget Dashboard"
Professional formatting. Clear titles and legends.

```

---

**Phase 6: Final Formatting (5 minutes)**

```
Apply professional formatting across all sheets:
- Currency columns: USD, zero decimals
- Percentage columns: 1 decimal place
- Headers: bold, centered, background color
- Apply borders to all data cells
- Auto-fit column widths

```

Then do your manual verification. Check totals. Spot-check formulas. Make sure the logic is sound before it goes anywhere official.

⚠️

Always verify Copilot's calculations before using them in anything client-facing or official. Copilot generates based on patterns — it doesn't guarantee accounting accuracy. Your professional judgment is the quality control layer.

---

## Copilot in Teams: The Privacy Rules

You'll want to use Copilot in Teams meetings for summaries and action items. Here's when it's appropriate — and when it's not.

**Use it for:**

- Internal team meetings on general topics
- Project status updates with colleagues
- Training or knowledge-sharing sessions
- Meetings you're hosting, where you control recording permissions

**Don't use it for:**

- Confidential client discussions without explicit consent
- Sensitive HR or personnel matters
- Meetings you're attending as a participant (not the host)
- Any conversation where participants haven't consented to AI assistance

The rule of thumb: if you're not the host, don't activate Copilot without asking.

**How it works:**  
The Copilot button (separate from the recording button) uses real-time transcription to generate a summary, action items, and key decisions. By default, only you see the output — it doesn't automatically share to other participants.

For your own team meetings where you're the host, this is a straightforward time-saver. After the meeting, you have a structured summary and action item list ready to send.

---

## Copilot in Word: The Same Approach, Different Surface

If you've been using Copilot in Outlook to generate emails from bullet points — and getting good results — the same approach works in Word.

You give it context and desired output. It drafts. You refine.

The prompting logic is identical. The surface is different.

```
Draft a professional memo announcing the annual budget 
review process. Include the timeline, required inputs from 
each team, and the submission deadline of [date].

```

That's it. You get a structured draft. You edit. You send.

---

## Your Three-Tool Stack

By now, the full picture looks like this:

**On your personal device:**  
Claude Pro for deep research, document analysis, and complex problem-solving. Your learning environment. Your research accelerator.

**On your work computer, for client and tax work:**  
Your firm's internal AI assistant for domain-specific research within quality-controlled, approved data sources.

**On your work computer, for productivity:**  
Microsoft Copilot across Excel, Outlook, Teams, and Word for daily workflow automation.

Each tool has a lane. Using them in the right lane is what keeps you effective — and compliant.

🔥

The professionals building a real AI advantage right now aren't the ones who found one great tool. They're the ones who built a clean, organized stack — the right tool for the right job — and got genuinely good at all of it.

---

## This Week's Practice

Open your actual budget file (or a real Excel file you're working on). Save it to OneDrive. Enable Auto-Save. Open Copilot.

Start with just one prompt: extract a subset of data into a new sheet.

See how it responds. Refine the prompt. Get the output where you want it.

Then do the same with Outlook. Take an email you're about to write. Bullet-point your key messages. Hand those bullets to Copilot and see what it produces.

You'll edit. That's fine. The goal is to stop starting from scratch.

---

## The Takeaway

Copilot works. But you have to set it up right, use it in the right contexts, and verify what it produces.

The professionals who get the most out of enterprise AI aren't the power users who automate everything. They're the ones who automate the right things — the repetitive, time-consuming tasks that eat hours and don't require their professional judgment — so they can put that judgment where it actually matters.

---

*Previous:* [*Platform Architecture: Why the Tool You're Using Might Be Holding You Back*](https://deletosh.com/writing/ai-platform-architecture-claude-pro)
### Platform Architecture — Why the Tool You're Using Might Be Holding You Back
URL: https://deletosh.com/writing/ai-platform-architecture-claude-pro/
Last updated: 2026-07-13T10:16:35.000Z
*Part 3 of 5 in the series: AI at Work — A Professional's Field Guide*

---

**What is the difference between an AI aggregator and direct access?** An aggregator bundles several models (Claude, ChatGPT, Gemini) into one subscription but usually serves an older version of each, while direct access (Claude.ai Pro, ChatGPT Plus) gives you the current model with full features and no version lag. For serious research and document work, that gap decides output quality. The Pipeline tests these platform choices so you do not have to.

Here's something nobody explains when they hand you an AI subscription:

Not all access to the same AI is equal.

You might be using a platform that gives you Claude — but an older, less capable version. You might be paying for a bundle that sounds good but limits what you can actually do. And the gap between "good enough" and "best available" matters more than most people realize.

This article breaks down the platform landscape so you know what you're actually using — and what upgrade, if any, is worth making.

---

## Aggregators or direct access: what is the difference?

There are two ways to access most major AI models.

**Aggregator platforms** bundle multiple AI models — Claude, ChatGPT, Gemini — into one subscription. They're convenient. But they typically give you older versions of each model. Not the current, most capable version.

**Direct access platforms** — Claude.ai, ChatGPT Plus, Google Gemini — give you the latest model directly. Full features. Current capabilities. No version lag.

The difference isn't obvious until you're doing complex work.

Think of it this way: it's the difference between subscribing to a legal research service that pulls from last year's databases vs. one with current case law. The older version gets you "good enough." The current version gets you what you actually need.

ℹ️

An aggregator platform providing Claude access might be giving you Claude 3.5 Sonnet — the previous generation — while Claude.ai Pro gives you the current model with extended context, advanced reasoning, and research capabilities. Same name, meaningfully different performance on complex tasks.

---

## The Case for Claude Pro

For professionals doing serious research, document analysis, and complex problem-solving: the $20/month Claude Pro subscription is worth it.

Here's what you get that aggregators don't provide:

**Latest model access**  
Current model generation, not a version behind.

**Extended context window**  
Longer conversations without the AI losing track of earlier context. Critical for multi-document analysis or extended research sessions.

**Projects**  
Persistent conversation organization. You can maintain context across sessions on the same topic.

**Research mode**  
Claude can search the web in real time and cite sources. This changes research from "AI's best guess" to "AI-synthesized current information."

**Desktop app**  
Claude Desktop integrates into your workflow outside the browser. Faster. More stable. Drag-and-drop file analysis without friction.

💡

****Installing Claude Desktop:** Visit claude.ai/download. Download and install for your OS. Sign in with your Claude Pro credentials. Use Command+N (Mac) or Ctrl+N (Windows) to start a new research prompt with the research toggle enabled.

---

## The Research Mode Workflow

Once you're in Claude Desktop, here's the workflow for serious research:

1. Press **Command+N** to open a new prompt
2. Enable the **research toggle** before you type anything
3. Apply your Role-Context-Task framework
4. Claude searches relevant sources, synthesizes findings, and cites them

Here's what a research-mode prompt looks like in practice:

```
Role: I am a senior tax consultant at a large professional 
services firm

Context: A client is considering investing in a partnership 
that generates UBTI, and I need to understand the filing 
requirements for tax-exempt investors

Task: Research the Form 990-T filing requirements when 
tax-exempt entities receive K-1s with UBTI, including 
thresholds and penalties for non-compliance

```

With research mode enabled, Claude searches current sources, pulls relevant guidance, and produces a structured research brief — with citations you can verify.

---

## What About Your Firm's Internal Tools?

Here's how to think about the full stack:

**Your firm's AI assistant (e.g., BlueJ at Deloitte)**  
Domain-specific, trained on vetted sources, appropriate for client-facing research. Use for anything that requires firm-level quality control or uses confidential client data.

**Claude Pro (personal device only)**  
Deep research, document analysis, complex reasoning. Use for personal learning, research preparation, and non-confidential work. Never for confidential client data.

**Microsoft Copilot (on your work computer)**  
Integrated into Excel, Outlook, Teams, Word. Use for daily productivity automation within firm-approved systems.

⚠️

Your firm likely blocks Claude and other public AI tools on work computers — this is intentional security policy. Use Claude on your personal device for learning and research. Use firm-approved tools (Copilot, your internal assistant) on work systems.

---

## The Excel Analysis Upgrade

With Claude Desktop and Pro, you're not limited to PDFs. You can upload Excel files.

For a tax professional, this opens up:

- Uploading anonymized K-1s and asking for line-by-line analysis
- Reviewing tax provision workpapers for calculation inconsistencies
- Uploading multi-year returns and asking for trend analysis
- Verifying PFIC calculations or passive activity tracking

The workflow is identical to document analysis — drag the file into Claude Desktop, apply your Role-Context-Task framework, and go interactive.

Same rules apply: anonymize everything. No real client names, SSNs, EINs, or confidential figures.

---

## The Deloitte AI Lab Problem

In our sessions, the client attended an internal AI training at her firm — focused on agent building using Amazon Bedrock. The content was technically sophisticated. The delivery was fast. No follow-along materials. No practical templates.

She left more confused than when she arrived.

This is a common problem with enterprise AI training. It prioritizes technical concepts over practical application. It shows you what's possible without giving you a foundation to actually do it.

The solution isn't to skip firm training. Attend it — it keeps you current on what's being built internally. But supplement it with practical, hands-on skill-building that starts with the fundamentals: prompting, document analysis, platform selection.

Everything else becomes clearer once you have that foundation.

🔥

The professionals who will lead AI adoption inside large firms aren't the ones who attended the most internal training. They're the ones who built practical skills through real-work application — and can now translate between technical AI concepts and actual professional use cases.

---

## This Week's Practice

If you haven't yet: subscribe to Claude Pro and install Claude Desktop.

Run one significant research query using research mode. Apply your Role-Context-Task framework. Compare the depth and quality of output to what you'd get from your aggregator platform or a basic web search.

Then find an Excel file you can anonymize. Upload it to Claude Desktop. Ask for analysis. See what it can do.

---

## The Takeaway

The tool you're using matters. Not all AI access is equal.

Know what version of each model you have access to. Understand what direct-access platforms unlock. And keep your stack organized: firm tools for client work, Claude for research and analysis on personal devices, Copilot for daily productivity at work.

---

*Next:* [ *Enterprise AI: How to Use Copilot at Work (Without Getting Fired)*](https://deletosh.com/writing/microsoft-copilot-work-enterprise-ai)

*Previous:* [ *Document Analysis: The Superpower Most Professionals Miss*](https://deletosh.com/writing/ai-document-analysis-professionals)
### Document Analysis — The Superpower Most Professionals Miss
URL: https://deletosh.com/writing/ai-document-analysis-professionals/
Last updated: 2026-07-13T10:16:58.000Z
*Part 2 of 5 in the series: AI at Work — A Professional's Field Guide*

---

**What is AI document analysis?** It is uploading a file, a form, regulation, or client document, directly into an AI tool and having a structured, section by section conversation about that exact document, instead of describing it from memory. It turns a general research assistant into a specialized expert that has read your specific page. Below is the exact workflow professionals use, the prompt template, and the safety rules that keep client data protected. If this is the kind of practical AI workflow you want weekly, The Pipeline is where it goes deeper.

Most professionals use AI as a question-answering machine.

Ask a question. Get an answer. Move on.

That's useful. But it's not where the real leverage is.

The real leverage is document analysis — uploading the actual file, form, or regulation and having a structured conversation about it. This changes AI from a research assistant into a specialized expert that's read your exact document.

---

## Why does uploading a document change what AI can do?

When you describe a problem to AI, you're working from memory and summary. Important details get lost.

When you upload the document, the AI works from the same source you do. It can reference specific sections, flag inconsistencies, explain requirements in context, and answer follow-up questions about that exact document.

For professionals who work with complex forms, regulations, and client files — this is the difference between getting general guidance and getting specific answers.

---

## How It Works in Practice

Here's a real scenario from our sessions.

A deadline hits. A client needs Form 8865 filed. It's a form the professional hasn't worked with recently. No time for a full research session.

Instead of spending an hour in research databases, she uploaded the blank IRS form directly into Claude and used this prompt:

```
Role: I am a tax professional

Context: Attached is Form 8865 — I need to understand all 
sections for accurate client filing

Task: Walk me through understanding this form as required by 
the IRS, section by section. Before moving on to the next 
section, ask and clarify my understanding.

```

The result: a guided, interactive walkthrough of the form. She could stop, ask questions, and move at her own pace. The AI checked her understanding before proceeding.

Deadline met. Client delivered.

✅

This is the document analysis workflow in action: upload the form or regulation, use the Role-Context-Task framework, and request an interactive walkthrough. The AI becomes your expert guide through the document — not just an answer machine.

---

## The Document Analysis Workflow

**Step 1: Prepare your document**  
Use blank IRS forms, public regulations, or anonymized client files. Never upload documents with real client names, SSNs, EINs, or confidential financial data into public AI tools.

**Step 2: Upload via drag and drop**  
In Claude, drag the PDF directly into the chat window. No complex setup required.

**Step 3: Apply the framework**  
Your Role-Context-Task prompt should reference the attached document and specify what kind of analysis you need.

**Step 4: Go interactive**  
Don't just ask for a summary. Ask for a section-by-section walkthrough. Request that the AI pause and check your understanding. Ask follow-up questions. Treat it like a conversation with a knowledgeable colleague.

---

## What You Can Do With This

**Unfamiliar forms under deadline pressure**  
Upload the form. Get an expert walkthrough. Handle it with confidence.

**Complex regulations you need to apply**  
Upload the regulatory text. Ask how it applies to a specific client scenario.

**Partnership K-1s and multi-entity filings**  
Upload multiple K-1s. Ask the AI to compare them and flag inconsistencies.

**Client documents you need to review quickly**  
Upload workpapers or prior-year returns (anonymized). Ask for a summary of key issues, trends, or areas requiring attention.

⚠️

This capability is for your personal device only. Never upload client documents with real identifying information into any public AI tool — even for analysis. Use blank forms, public guidance, and anonymized examples.

---

## Going Further: Interactive Research on Complex Topics

Document upload also works for research — not just form analysis.

For complex topics like PFIC/PIRC elections, here's what a strong research prompt looks like:

```
Role: I am a tax specialist at a global consulting firm

Context: I'm looking to understand PFIC/PIRC elections and 
their practical implications for investment partnerships

Task: Walk me through all the practical applications with 
step-by-step calculations and examples

```

This kind of prompt — specific role, narrow context, clear task — consistently produces research that's structured, practical, and thorough enough to use as a starting framework before you go to authoritative sources for verification.

---

## Platform Comparison: Research Depth

When we ran complex tax research prompts across platforms, the difference was clear:

- **Claude** consistently delivered comprehensive guidance in a single, well-structured prompt.
- **Gemini** required some additional prompting to reach the same depth.
- **ChatGPT** often needed multiple follow-up exchanges to match Claude's initial output.

For document analysis and deep research, Claude is the right tool for this kind of professional work.

📝

Always cross-reference AI analysis with authoritative sources — IRS.gov, your firm's premium research databases, official regulatory sites. AI gives you speed and structure. Authoritative sources give you verification.

---

## This Week's Practice

Find two or three forms you work with regularly. Blank IRS forms work perfectly.

Upload each one into Claude. Use the document analysis prompt template above. Ask for a section-by-section walkthrough — and stop the AI at each section to test your own understanding.

Then try it with a regulation or guidance document you're currently working through.

The goal isn't to replace your research process. It's to accelerate it.

---

## The Takeaway

Document upload transforms AI from a question-answering machine into a specialized expert that's read your exact document.

For professionals who live in complex forms, regulations, and client files — this is the capability that changes how fast you can operate.

---

*Next:* [*Platform Architecture: Why the Tool You're Using Might Be Holding You Back*](https://deletosh.com/writing/ai-platform-architecture-claude-pro)

*Previous:* [ *AI Fundamentals: What's Actually Happening Under the Hood*](https://deletosh.com/writing/ai-fundamentals-professionals)

---
### AI Fundamentals — What's Actually Happening Under the Hood
URL: https://deletosh.com/writing/ai-fundamentals-professionals/
Last updated: 2026-07-13T10:15:07.000Z
*Part 1 of 5 in the series: AI at Work — A Professional's Field Guide*

---

**What is a large language model, and why does it matter for professionals?** Every AI tool you use (ChatGPT, Claude, Gemini, or your firm's assistant) runs on a large language model: a system trained on huge amounts of text that predicts the most probable useful response to your prompt. It is pattern recognition, not thinking, which is why the structure of your prompt decides the quality of your output. Understand that, and you prompt like a specialist instead of a tourist. The Pipeline breaks down these professional AI workflows every week.

Most professionals using AI tools don't know how they work.

That's not a criticism. You don't need to know how a Bloomberg terminal calculates bond duration to use it. But with AI, understanding the basics changes how you prompt — and that changes everything.

Here's what you need to know.

---

## Is AI magic, or just pattern recognition?

Every AI tool you've used — ChatGPT, Claude, Gemini, your firm's internal assistant — is built on the same thing: a Large Language Model (LLM).

An LLM is trained on enormous amounts of text. It learns patterns. When you ask a question, it predicts the most probable useful response based on those patterns.

That's it.

No thinking. No understanding. No database lookup (unless the tool has search enabled). Just pattern prediction — at a scale that produces remarkably useful outputs when prompted correctly.

ℹ️

This is why AI can "hallucinate" — confidently produce false information. It's generating a probable response, not retrieving a verified fact. Always verify critical claims through authoritative sources.

---

## The Tools in Your Stack

If you're a professional at a large firm, you're likely juggling multiple AI tools. Here's how to think about them:

**Internal enterprise tools (e.g., your firm's AI assistant)**  
Built specifically for your industry. Trained on or constrained to vetted data sources. More reliable for domain-specific work. Use these for client-facing research.

**Direct-access public AI (e.g., Claude Pro, ChatGPT Plus)**  
The latest model versions. Most powerful for complex analysis, document work, and research. Use on personal devices only — never input confidential client data.

**Integrated productivity AI (e.g., Microsoft Copilot)**  
Embedded in the tools you already use — Excel, Outlook, Teams, Word. Works with your existing files. The right tool for automating daily workflow.

**Aggregator platforms (e.g., Nova, Poe)**  
Bundle multiple AI models in one subscription. Convenient. But they often give you older model versions — not the current, most capable ones. Useful for quick comparisons. Not the right choice for serious work.

⚠️

Never input confidential client information into public AI tools — even if you trust the platform. This applies to ChatGPT, Claude, Gemini, and any tool outside your firm's approved environment. Use internal tools for client-specific work.

---

## The Framework That Works Everywhere

Here's the most important thing in this series.

Every AI tool you use responds to the same input structure. We call it **Role-Context-Task**.

```
Role: Who you are (gives the AI professional context)
Context: What situation you're in (narrows the scope)
Task: What you specifically need (clear, actionable instruction)

```

Compare these two prompts:

**Without the framework:**

> "Tell me about 2025 FINRA regulations."

**With the framework:**

> Role: I am a tax specialist at a Big Four firm.  
> Context: I'm researching regulatory changes to support a client's tax withholding compliance.  
> Task: Walk me through all 2025 changes to FINRA regulations relevant to withholding obligations.

Same question. Completely different output.

The first gets you a Wikipedia summary. The second gets you a structured briefing you can actually use.

💡

****How to type it in one prompt:** Use Shift+Enter to create line breaks within a single message. This keeps all three elements together so the AI reads them as one structured prompt — not as separate messages.

---

## Platform Comparison: What Actually Happened

Early in our sessions, we ran the same tax research question across three platforms. Same Role-Context-Task prompt. Here's what we found:

**Claude** — Delivered comprehensive, structured results in one prompt. Step-by-step guidance with practical applications. Minimal follow-up needed.

**Google Gemini** — Competitive results with good source citations. Required slight additional prompting for depth.

**ChatGPT** — Needed multiple follow-up prompts to reach comparable quality.

For complex professional research outside your firm's internal tools, Claude consistently outperforms for depth and structure.

---

## What This Week's Practice Looks Like

Pick one real work question you're sitting on. Something you'd normally Google or look up in a research database.

Apply the Role-Context-Task framework in Claude (on your personal device). Compare the result to what you'd get from a generic Google search.

Then cross-reference the AI output with an authoritative source — your firm's research databases, official regulatory sites, whatever applies.

That combination — AI for speed and structure, authoritative sources for verification — is the workflow.

🚨

AI output is never your final answer on client work. It's your starting point. Always verify through authoritative sources before anything goes to a client.

---

## The Takeaway

AI isn't magic. It's a pattern-matching tool that responds to structure.

Give it role, context, and a specific task. Verify what it gives you. Use the right tool for the right situation.

That's the foundation. Everything else in this series builds on it.

---

*Next:* [ *Document Analysis: The Superpower Most Professionals Miss*](https://deletosh.com/writing/ai-document-analysis-professionals)

*Previous:* [*You're Using AI Wrong at Work*](https://deletosh.com/writing/ai-at-work-professionals-guide)
### You're Using AI Wrong at Work. Here's How to Fix It.
URL: https://deletosh.com/writing/ai-at-work-professionals-guide/
Last updated: 2026-07-13T10:16:17.000Z
**What is the biggest mistake professionals make with AI at work?** Treating AI like a search engine: typing a vague question and hoping for the best. The fix is a repeatable prompt structure and knowing which tool (internal, public, or embedded) to use for each task, so you get client-ready output instead of generic answers. This series is the field guide for professionals in tax, legal, and consulting. The Pipeline continues it every week.

I coached a senior tax manager at a Big Four firm.

Sharp professional. Deep technical expertise. Twenty-plus years in practice. And when we started working together, she was using AI the same way most professionals do — typing questions into ChatGPT and hoping for the best.

Sound familiar?

Over four sessions, she went from AI uncertainty to using it daily across research, document analysis, Excel automation, and client communications. Real work. Real tools. Real results.

This series is the playbook from those sessions — adapted for any professional navigating AI at a large firm.

📝

This series draws from real coaching sessions with a professional at a Big Four firm. Client details have been anonymized. The tools, frameworks, and workflows are exactly what we used.

---

## What is the problem most professionals have with AI?

They're treating it like a search engine.

You type a vague question. You get a generic answer. You're not sure if it's accurate. You go back to doing it manually.

That's not AI failure. That's prompt failure.

The other problem: professionals at large firms are navigating a complicated toolkit — internal enterprise tools, approved external tools, and public AI tools with real security restrictions around them. Nobody has explained how to use them together.

That's what this series does.

---

## What We'll Cover

**AI Fundamentals: What's Actually Happening Under the Hood**  
Why all AI tools work the same way — and why that means one framework works everywhere.

**Document Analysis: The Superpower Most Professionals Miss**  
How to turn any PDF, form, or regulation into an interactive research session.

**Platform Architecture: Why the Tool You're Using Might Be Holding You Back**  
Aggregators vs. direct access. And why the $20/month upgrade is worth it.

**Enterprise AI: How to Use Copilot at Work (Without Getting Fired)**  
The infrastructure requirements, the security rules, and the complete budget workflow.

---

## The One Thing to Know Before You Start

Every AI tool — whether it's ChatGPT, Claude, Gemini, Copilot, or your firm's internal system — is built on the same foundation. Large Language Models that predict probable responses based on patterns in text.

That means the quality of what you get out is almost entirely determined by the quality of what you put in.

Better prompts. Better results. Every time.

The framework for doing that — and how to apply it across every tool in your stack — starts in Article 1, the AI Fundamentals.

If you only read one article in this series, make it this. The Role-Context-Task framework is the foundation everything else builds on.

---

*Next:* [*AI Fundamentals: What's Actually Happening Under the Hood*](https://deletosh.com/writing/ai-fundamentals-professionals)
### Setup Docassemble Document Automation Locally
URL: https://deletosh.com/writing/docassemble-local-setup/
Last updated: 2026-03-05T01:27:49.000Z
In this guide, we will setup our system to run docassemble without using the playground or a server.

This allows us to use a regular text editor, save our work so we can collaborate on interviews with colleagues and we get an easier way to use MS docx templates with docassemble.

This article is part of the series on using document automation with docassemble.

At the end of this guide, you will be able to design an interview this way:

![Running docassemble locally](https://deletosh.com/app/uploads/2024/02/aaoZL9h.gif)

if you’re not comfortable with docassemble yet, use it from [the playground](https://demo.docassemble.org/run/legal/?ref=deletosh.com#/1)

### Requirements to install docassemble on your system

First, confirm your system has these minimum requirements:

- [It meets the minimum requirement to install the app, docker](https://docs.docker.com/desktop/install/windows-install/?ref=deletosh.com)
- You have a stable internet connection. Some of the apps you will download and install through this process are heavy.

If you’re good with this, let’s get into the steps.

## Install docker for docassemble

Docker is like a computer within your computer. It allows you to run an application that you won’t otherwise be able to install and run on your computer.

Let’s install it:

[Go to docker’s website](https://docs.docker.com/get-docker/?ref=deletosh.com) and download the proper version for your operating system. Through the rest of this guide, I will use Windows.

When the download is complete, we’ll run the installation file. I’m starting from this point:

![Download docker to desktop](https://deletosh.com/app/uploads/2024/02/zZ6yDfe.png)

As I open it, I get this notification:

![Allow device modification](https://deletosh.com/app/uploads/2024/02/g93EEW3.png)

Continue the rest of the install. Accept all the default options.

With docker installed, we install the software that allows us to track changes to our files, Git and GitHub.

### Install Github and Git to allow docassemble Source Control

Go to [https://desktop.github.com/](https://desktop.github.com/?ref=deletosh.com) to download GitHub Desktop.

![Download and install GitHub desktop](https://deletosh.com/app/uploads/2024/02/W649EiY.png)

While installing this is all you see:

![GitHub in the installation process](https://deletosh.com/app/uploads/2024/02/EBzCtyu.png)

Hang in there, it’s installed in the background.

When it’s complete, you get this screen:

![GitHub installation complete](https://deletosh.com/app/uploads/2024/02/scIdBqU.png)

At this point, you have 2 options:

If you don’t have a GitHub account , click **Create your free account** or [do it here](https://github.com/signup?ref=deletosh.com), then continue to the next step.

GitHub is the website that allows you to collaborate with others. Think of GitHub like a group email inbox for documents, but unlike email, GitHub allows us to track all the changes on those documents.

With your new (or exciting) GitHub account, click the **Sign in to GitHub.com**.

![Sign in to GitHub from the Desktop App](https://deletosh.com/app/uploads/2024/02/06YuTLX.gif)

When that’s complete, it brings us back to this:

![Confirm Git Details](https://deletosh.com/app/uploads/2024/02/p3gCEGD.png)

Confirm the details are correct and click **Finish**.

With this done, we’re ready to start automating our documents with Docassemble.

## Write a sample docassemble interview from your system

To confirm all works, we will try a sample document assemble project.

Open your GitHub desktop. Click **Clone a repository from the Internet…** select **URL**, in the text box enter: **deletosh/docassemble-premier** then click **Clone**.

![Create a copy of the project on your computer](https://deletosh.com/app/uploads/2024/02/tZEU7NF.gif)

Finally, to see what all the files look like, hit **Repository** \> **Open in Visual Studio**

![Open project in VS Code](https://deletosh.com/app/uploads/2024/02/OUTJCFu.gif)

With our VS Code open, confirm we can run an interview on our computer. Click through **docassemble** \> **template** \> **questions** then open **sample.yml**

![Open interview yml file](https://deletosh.com/app/uploads/2024/02/AlMV6Ce.gif)

To make working with coding docassemble easier, we want to add additional customization to VS Code.

## Install an alternative to Window’s “cmd”, Clink

We will be type several commands in the terminal (sometimes called, command line, or *cmd.exe*). It’s that app on Windows that looks like this:

![what does cmd.exe look like](https://deletosh.com/app/uploads/2024/02/fAUdhMX.png)

We want this to work better and make it easier to use inside VS code.

Go to [https://mridgers.github.io/clink](https://mridgers.github.io/clink?ref=deletosh.com) and **EXE (installer)**

![Download Clink for Windows](https://deletosh.com/app/uploads/2024/02/MxAYyUD.png)

Once you downloaded this, open and install the file. Keep all the default options.

Take note of where we installed the app. Mine is at **C:Program Files (x86)clink**.

![Install clink](https://deletosh.com/app/uploads/2024/02/PX2J8XQ.gif)

### Browsing through folders

Before we continue, let me expand on what “C:Program Files (x86)clink” means.

When you install any app on your computer, it saves it somewhere on your computer, in our case, that somewhere is “C:Program Files (x86)clink.” The first folder is “C:” (your main computer drive). Inside that we have the next folder “Program Files (x86)”; inside it we have “clink.”

To navigate to our final folder (clink), you open **Windows Explorer**, open **C:**, then **Program Files (x86)**, then **click** — the short way we represent the path to the final directory is “C:Program Files (x86)clink.”

Let’s move on.

With the install complete, go into the folder you installed click. Mine is **C:Program Files (x86)clink**, go into the version folder **0.4.9**. Here’s how I get to my folder,

![Open Clink folder](https://deletosh.com/app/uploads/2024/02/TGR3d7m.gif)

## Add Clink command-line to VS Code

Let’s open VS Code. Click **File** \> **Preferences** \> **Settings**.

Click on the settings icon

![Open settings](https://deletosh.com/app/uploads/2024/02/jv8LMeK.png)

Add the text below within the “{ }” section

```
"terminal.integrated.shell.windows": "C:\Windows\System32\cmd.exe","terminal.integrated.shellArgs.windows": ["/K", "C:\Program Files (x86)\clink\0.4.9\clink_x64.exe"," inject"]
```

![Add the settings to configure the terminal](https://deletosh.com/app/uploads/2024/02/UnlSSPJ.png)

(Note that the path in terminal.integrated.shellArgs.windows  
In the **Search settings** box, enter **terminal** and in the **Terminal: Explorer Kind** select **integrated**

To confirm this is working as expected, open the terminal. Click **Terminal** \> **‌New Terminal**

![Open a new terminal](https://deletosh.com/app/uploads/2024/02/PFRtojR.gif)

We should see **Clink v0.4.9**.

## Install Python and docassemble command-line app

Next, we will install python.

Python is a programming language, and that’s docassemble’s parent language. To make docassemble work properly offline, we need to install on our system.

Go to [https://www.python.org/downloads/windows/](https://www.python.org/downloads/windows/?ref=deletosh.com), Click the most recent version and download.

![Download the proper python version](https://deletosh.com/app/uploads/2024/02/zNe5Gxm.gif)

Open the downloaded file. Before starting the installation, check the box **Add Python 3.x to PATH**, click **Install Now**

![Start the installation](https://deletosh.com/app/uploads/2024/02/bLUCfR0.png)

When your installation is complete, open VS Code and a new terminal then type **python**, it should look like this:

![Check python works in your integrated terminal](https://deletosh.com/app/uploads/2024/02/gXLRh3F.gif)

If you see a message like the above, we’re good.

We’re now ready for the final step.

## Install docassemble command-line tool (docassemblecli)

With python installed, let’s install the tool that let’s run docassemble locally.

Open VS Code, click **Terminal** \> **‌New Terminal** in the terminal enter `pip install docassemblecli`

![Install docassemblecli tool](https://deletosh.com/app/uploads/2024/02/pAwsq53.gif)

Let’s run everything together

In the terminal, type `docker-compose up -d` . This is the command that starts a virtual computer.

![Run docker composer](https://deletosh.com/app/uploads/2024/02/BDRxdhx.gif)

Open your browser and go to `http://localhost`. You might see this

![Docassemble starting](https://deletosh.com/app/uploads/2024/02/VaFLb62.png)

After a few minutes, you should see Docassemble running. Sign in with the default password:

- username: admin@admin.com
- password: password

![](https://deletosh.com/app/uploads/2024/02/NMMUBUU.gif)

(the first time you login, it will have you change your password)

## Run your first offline docassemble

Our main setup is now complete. Let’s test our first interview.

First, go to Docassemble running on your system. In your browser, type **[http://localhost](http://localhost/?ref=deletosh.com)**, in the navigation section, click **My Profile**.

![Go to profile](https://deletosh.com/app/uploads/2024/02/Wq4KE1X.png)

On the next page, go to the **Other settings** \> **API keys**

![Go to API keys](https://deletosh.com/app/uploads/2024/02/JpBul6N.png)

Click **‌Add a New API Key** and give it any name. Then click **Create**.

Finally, copy the resulting key

![Create API key](https://deletosh.com/app/uploads/2024/02/FLTtjRn.gif)

Now, go back into VS Code with the project you previously created open.

Type `code ~/.docassemblecli`, this opens a new tab in VS Code.

In this section:

![VS Code](https://deletosh.com/app/uploads/2024/02/G1BcHx3.png)

Paste the API code you created in the previous section in the **apikey**. Save the file or `Ctrl + S`

![Add API key](https://deletosh.com/app/uploads/2024/02/8fmkOs3.gif)

Next, let’s rename the **docassemble** \> **template** file to **docassemble-premier**

![Rename to the docassemble project](https://deletosh.com/app/uploads/2024/02/GSOfFNJ.gif)

Let’s now open the **sample.yml** file

Next, type `dainstall --norestart --playground ../docassemble-premier`

![Install the package](https://deletosh.com/app/uploads/2024/02/Lg1kWIr.gif)

You should see **Installed**.

You can now go back to the browser at [http://localhost](http://localhost/?ref=deletosh.com), then go to the **‌Playground**

Let’s run the code.

![Run interview](https://deletosh.com/app/uploads/2024/02/aaoZL9h.gif)

You’re now good at developing Docassemble interviews from your system.

## How to continue docassemble from locally

As you run your project, here are some things you need to keep in mind:

- Every docassemble project is self-contained and you need to shut down docker and re-start docker in that project.
- When you start a new project, you need to add and re-create your API keys. You cannot use the API key you’ve added before.

Docassemble allows you to automate your document assemble process, and it’s a free alternative to the expensive hotdocs. This setup makes it flexible for you to write your interview and collaborate with other colleagues.

Let me know if you have questions in the comments.
### Setup a self-hosted Ghost CMS on CapRover
URL: https://deletosh.com/writing/ghostcms-caprover-install/
Last updated: 2024-02-21T16:33:25.000Z
Ghost CMS is a simpler and faster WordPress alternative with a big problem: the price ($29 – 299/month!). In this guide, I share an easy way to set up Ghost CMS on your own server using [CapRover](https://caprover.com/?ref=deletosh.com).

At the end of this guide, you can have a website like [Buffer’s blog](https://buffer.com/resources/?ref=deletosh.com) or this website (deletosh.com) without the high-cost.

![Buffer blog, hosted on Ghost](https://deletosh.com/app/uploads/2024/02/9cOethZ.png)

Before you start, confirm you have:

1. A steady internet connection. If you don’t have a steady connection, this process will fail in random places—save yourself the stress.
2. You’ve [installed CapRover on a server](https://caprover.com/docs/get-started.html?ref=deletosh.com). I recommend a [cheap server from SSDNodes](https://www.ssdnodes.com/?ref=deletosh.com).

Got those? Let’s start.

## Install Ghost CMS on CapRover using a custom template

Open your CapRover Dashboard.

Go to **Apps** \> **One-Click Apps/Database**

![](https://deletosh.com/app/uploads/2024/02/JWEPhms.gif)

Type in **template** and select **\>> TEMPLATE <<**

![](https://deletosh.com/app/uploads/2024/02/P6DnZfL.gif)

In the text-box, copy the content of [this file](https://github.com/deletosh/ghost-caprover/blob/main/docker-compose.bitnami.caprover.yml?ref=deletosh.com) into the box and tap “Next”

![](https://deletosh.com/app/uploads/2024/02/zbVwqul.gif)

Give your app a name, in my case, I enter: “ghost-cms-test” and hit **Deploy**

![](https://deletosh.com/app/uploads/2024/02/3nshZnx.gif)

Give this process a few minutes to run. You should now see this:

![Finish CapRover installation](https://deletosh.com/app/uploads/2024/02/ZH7govq.png)

Hit **Finish**.

Give the process about 5 – 10 mins to complete the full setup. If you’re curious, you can check the progress by going to **Apps** \> **your app name**\> **Deployment**

![How to check the progress of a new Caprover Ghost App](https://deletosh.com/app/uploads/2024/02/UghUTLn.gif)

Go to the **HTTP Settings**“, in the **Container HTTP Port** change the “80” to “2368”, then “Save & update”

![How to set Ghost container port on CapRover](https://deletosh.com/app/uploads/2024/02/Wy5EJn7.png)

After that saving completes, you should now have access to the site.

To login, go to **[http://your-new-captain-url/ghost](http://your-new-captain-url/ghost?ref=deletosh.com)** with these default credentials:

username: **user@example.com**”

password: **bitnami123**

![How to login to Ghost install with bitnami docker](https://deletosh.com/app/uploads/2024/02/vt7iC2Q.gif)

## My Ghost Installation on CapRover Failed! What next?

### CapRover Installation Failed Before Seeing the Last Screen

Tap the “Go Back & Try Again”, delete all the related apps and start the process again.

![](https://deletosh.com/app/uploads/2024/02/rsN5Nr4.gif)

### Everything seems to work on “Deployment” but things are not looking right?

**Restart CapRover**. To do this, login to your server with ssh and run `docker service update captain-captain --force`.

---

You should know have your Ghost website installed and saved yourself $29 – $199 every month. If that’s not enough reason for you, enjoy how simple and fast Ghost is comparable to WordPress. Now [pick a theme](https://dessign.net/free-ghost-themes/?ref=deletosh.com) and enjoy!

Got questions? Drop it in the comment and share this article with friends and colleagues that will find this need a free ghost setup.
### How to Sync Logseq Notes Across Windows, Mac and Mobile
URL: https://deletosh.com/writing/sync-logseq-notes-all-devices/
Last updated: 2024-02-21T16:33:50.000Z
A painful problem with Logseq is: the iOS mobile app needs iCloud to sync to your notes. On my other devices I prefer and use Dropbox. Let’s fix it.

In this guide, I will share how to sync your notes from Dropbox (or Google Drive) on your other devices to iCloud on iOS (iPhone and iPad).

At the end of this guide, here’s what we will have:

![The setup I want to achieve](https://deletosh.com/app/uploads/2024/02/Lp9pGnY.png)

The setup we want to achieve

## Desktop Logseq Notes Sync Setup

To continue with this setup, you will need to install these apps

- [Dropbox](https://www.dropbox.com/install?ref=deletosh.com). Link the Logseq on your Mac or Windows to this folder.
- [SyncTime](https://apps.apple.com/us/app/synctime/id590386474?mt=12&ref=deletosh.com) (if you’re on Windows, use [bvckup2](https://bvckup2.com/?ref=deletosh.com), on Linux use [rysnc](https://www.redhat.com/sysadmin/sync-rsync?ref=deletosh.com))

After SyncTime install, update your mac **Login Items** so SyncTime starts when you logon your computer.

![How to set SyncTime to start at login](https://deletosh.com/app/uploads/2024/02/jTwwYAR.gif)

How to set SyncTime to start at login

Next, inside your Dropbox folder, create a folder for your Logseq notes.

![The Dropbox folder on my Mac](https://deletosh.com/app/uploads/2024/02/FQdGzB0.png)

The Dropbox folder on my Mac

On your mac, create the Logseq directory inside iCloud

![My iCloud folder with a Logseq folder](https://deletosh.com/app/uploads/2024/02/3v34tEf.png)

My iCloud folder with a **Logseq** folder

Create your SyncTime task to sync from the Dropbox -> iCloud directory

![Create the sync task from Dropbox to iCloud](https://deletosh.com/app/uploads/2024/02/sIe7vM3.gif)

Create the sync task from Dropbox to iCloud

After you’ve created the task, it should look like this:

![SyncTime General Tab](https://deletosh.com/app/uploads/2024/02/5bDjL7D.png)

SyncTime General Tab

1. The **Title** of this task
2. SyncTime sync schedule . In “automatic” this runs when it detects any changes.
3. My Logseq Dropbox folder
4. My iCloud folder

Our setup is complete.

Now, any notes we make to Logseq on our Mac will sync to your Logseq’s iCloud folder and any changes from the iCloud folder will sync to the Dropbox folder.

## iOS Logseq Notes Sync Setup

With this setup complete, let’s move over to the mobile app.

[download the Logseq mobile app on your iPhone or iPad](https://apps.apple.com/us/app/Logseq/id1601013908?ref=deletosh.com)

When it asks for your graph folder, choose the iCloud folder you created on your Mac.

Give it some time to sync, and you’re done!

With this, any change you make from your iPhone or iPad will sync back to iCloud, which syncs to your Mac. With SyncTime running, it automatically syncs it to Dropbox.

If you’re having issues, here are some things to check:

- If your notes are not updating properly on your mobile devices, install this iOS shortcut: [https://www.icloud.com/shortcuts/8bcba6316c2944ceb9e5a127f312b49b](https://www.icloud.com/shortcuts/8bcba6316c2944ceb9e5a127f312b49b?ref=deletosh.com)
- Your mac is the “control center” for syncing from Dropbox to iCloud. If you’re editing notes that are mainly on your Dropbox folder (for example on an Android phone), you will need to go through your mac to let SyncTime run and sync.
### Connect VS Code to GitHub for Legal Coding
URL: https://deletosh.com/writing/connect-vscode-github/
Last updated: 2024-02-21T16:45:55.000Z
If you’re a legal professional and want to automate your document assembling process at the unbeatable price of FREE, you’re in the right place.

Tools like theformtool, HotDocs, Pythagoras, etc have comparable feature, the cost adds up.

And for docassemble there’s a catch:

The learning curve is steep.

That’s where I come in.

In this series, I will guide you through everything that gets you from “this-is-strange” to “Wow! It’s incredible” in the next of my few articles.

Let’s now set up your “playground” — VS Code.

(I’m using Windows through this guide)

### Download VS Code from the website

On your browser, (in my case I’m using Google Chrome), go to [https://code.visualstudio.com](https://code.visualstudio.com/?ref=deletosh.com) and hit the “Download for X” button, the “X” will be the name of your operating system

![](https://deletosh.com/app/uploads/2024/02/NNjeUh4.png)

### Install VS Code

Once the download is complete, open the file and go through the install process (I’m demonstrating installation on Windows)

![](https://deletosh.com/app/uploads/2024/02/4ht4Dvf.gif)

As this completes, if you leave the “Launch VS Code” check, opens into this:

![](https://deletosh.com/app/uploads/2024/02/pwsHSLz.png)

Next, we connect our visual studio code to GitHub.

### Install the GitHub extension

To continue with this process, you will need to [sign up for a GitHub account.](https://docs.microsoft.com/en-us/visualstudio/version-control/git-create-github-account?view=vs-2022&ref=deletosh.com)

Once you’ve completed your GitHub account registration, return to the VS Code and click on the extension icon

![](https://deletosh.com/app/uploads/2024/02/2VFwiO5.png)

Type “GitHub” and click the “Install” in the dropdown

![](https://deletosh.com/content/images/2022/06/9NFoUCY.gif)

Now click the avatar icon in the bottom (it might now have the “1” pop-up) and click “Sign in with GitHub to use GitHub Pull Requests and Issues”. This process will open a new browser and have you login into GitHub.

![](https://deletosh.com/content/images/2022/06/gP1wJv3.gif)

Login with your GitHub credentials. It redirects you back to Visual studio code

You should now have your VS Code setup and connected to GitHub
### Learning to Learn
URL: https://deletosh.com/writing/learning-to-learn/
Last updated: 2024-02-22T22:12:08.000Z
## What counts as interesting?

When’s the last time you learned something useful? Something that really shifted your knowledge and made a difference.

How about the last time you found something “interesting” online—or several “interesting” things online?

Every day, you make this choice on your time:

- Sink it in a black hole
- Invest in yourself

Sadly, it’s easy to sink it in a black hole of interestingness.

In today’s world, the ability to learn quickly, extract information and create meaning is a competitive advantage. Because…

Ironically, even though there’s more information than ever, it’s easier than ever to get stuck in black holes.

Think of it this way:

You can either spend 60 mins a day getting sucked into the the world of needless interestingness OR invest the same amount of time in yourself, growing your knowledge, re-mixing knowledge and creating substance in the world.

## How

![](https://deletosh.com/app/uploads/2024/02/AmazonSmile_How_to_Take_Smart_Notes_One_Simple_.png)

## My Favorite Tip This Week

> Accept that Done is better than perfect, and you will be more productive and satisfied with your life. There is no such thing as perfection, you will struggle to cover that last 3% of your project, while you could be at 40% of your next one.
### The Art of Thinking Poorly
URL: https://deletosh.com/writing/the-art-of-thinking-poorly/
Last updated: 2024-02-21T14:55:13.000Z
## What does good thinking look like?

Thinking is hard work.

To write well, you must think well, that’s more work. And that’s a start.

To write well, read a lot. This helps you see what good writing looks like. You know what to steal and how to craft your own voice. Importantly:

You originate better thoughts—The road towards expertise.

Don’t let “gurus” fool you, the road to expertise is a long, patient and sometimes a painful one. It is equally rewarding.

## How

![](https://deletosh.com/app/uploads/2024/02/Amazon.com__on_writing_well_2021-01-26_02-33-49.png)

## My Favorite Tip This Week

> Don’t go straight for the coffee or tea when you wake up. Go straight to the water. Not only does that help hydrate you, but it also helps make you alert. And it’s also healthier.

### What I’m Enjoying Lately

![Seriously, this book is  ](https://deletosh.com/app/uploads/2024/02/Amazon.com__typography_for_lawyers_2021-01.png)

Seriously, this book is 

To your success,

Dele
### The Focus Problem
URL: https://deletosh.com/writing/the-focus-problem/
Last updated: 2024-03-01T17:23:30.000Z
## winning the war of art

It’s hard seeing things through.

Since I heard of the magpie, when someone hops from one thing to the next, I think of this bird.

The magpie is a very intelligent, like many. It collects shiny things, like many. And like many, it doesn’t see things through meaningfully.

lure of jumping to the next shiny object is more appealing than sticking to build a shiny object out of what you already have.

Is that you?

Do you give up because something more “interesting” or “practical” came along. Maybe you don’t want to admit to yourself that you’re not willing to stay in the grind?

Building anything meaningful is hard (regardless of what “gurus” like you to think) and I love it because, it naturally filters the wannabes from the real deal who get to enjoy the true gains of building something meaningful.

Which are you?

## How?

![An Unlikely Book on Maintaining Focus](https://deletosh.com/app/uploads/2024/02/Amazon.com__the_war_of_art_2021-01-17_15-48-59.png)

An Unlikely Book on Maintaining Focus

To your success,

Dele
### You, Inc.
URL: https://deletosh.com/writing/you-inc/
Last updated: 2024-02-21T14:54:44.000Z
## Is anything else more important than you?

This year, protect your best asset: you.

No matter how productive, inventive or anything else you might be, the best thing you can do for yourself is to take care of the only thing that is irreplaceable—yourself.

I don’t mean hire bodyguards, but be in the best of health possible. Exercise more? Eat healthier?

2020 was a year of the COVID-19, we’re unsure how that will play out this year and as you’ve read from me a few times last year—never stop keeping an eye out for opportunities, there’s lots of opening in the marketplace.

## My Favorite Article This Week

[A Complete Guide to Tagging for Personal Knowledge Management](https://fortelabs.co/blog/a-complete-guide-to-tagging-for-personal-knowledge-management/?ref=deletosh.com)

### What I’m Enjoying Lately

![Bill Bryson's Made in America](https://deletosh.com/app/uploads/2024/02/Amazon.com_made_in_america_An_Informal_History_.png)

Bill Bryson’s Made in America

Bill Bryson always delivers

Here’s to the best of your health in 2021
### An Anti-Forecast
URL: https://deletosh.com/writing/an-anti-forecast/
Last updated: 2024-03-01T17:18:39.000Z
## So… 2020, huh?

How has 2020 been for you so far?

With everything the world has been through this year, things will not be the same. The question for you is, how can you take advantage of the shift to put yourself or your product in a better place.

Think of your \[product\] positioning and think of the shift the market is having (and will have). Are they aligned?

What are the old tricks you should kills and the new opportunity you should pursue?

This is the time to look at the trends, look at the insights, and see how you can better position yourself for the future.

From what we’ve all seen this year, many things will just never go back to normal. An example, those who swore by office-or-nothing, gone. Sorry.

## My Favorite Article This Week

[Smart Things About That Lazy Employee You’re Not Seeing](https://smedigest.com.ng/smart-things-about-that-lazy-employee-youre-not-seeing.html?ref=deletosh.com)

### What I’m Enjoying Lately

![](https://deletosh.com/app/uploads/2024/02/Getty-Dubay_on_the_AppStore_2020-12-14_16-11-24.png)

Right, I’m learning to write properly again…

To your success,

Dele
### Getting Everything You Can - #1
URL: https://deletosh.com/writing/getting-everything-you-can-1/
Last updated: 2024-03-01T17:31:41.000Z
## Never fall in love with…

Hello friend,

In the next few emails, I will share lessons from my distant mentor, [Jay Abrahams](https://www.abraham.com/?ref=deletosh.com) (the 21.7 billion dollar man) — with application to digital products.

Here’s a start:

> **they fall in love with the wrong thing**

The wrong thing can even be your solution to a problem, it can be a your company’s ethos, it can be your teammates. You notice the trend — don’t fall in love with what you assume, fall in love with:

Your Clients and their problems.

## How

![This is the a must read for ANYONE interested in the business of software](https://deletosh.com/app/uploads/2024/02/The_Mom_Test_How_to_talk_to_customers__learn_if.png)

This is the a must read for ANYONE interested in the business of software

## My Favorite Article This Week

### [Social media promised to connect us, but made us isolated and tribal instead](https://www.bespacific.com/social-media-promised-to-connect-us-but-made-us-isolated-and-tribal-instead/?ref=deletosh.com)

### What I’m Enjoying Lately

![This is Now my Design Bible and Textbook - Thanks Adam!](https://deletosh.com/app/uploads/2024/02/Refactoring_UI_The_Book_2020-11-24_04-31-55.png)

This is Now my Design Bible and Textbook – Thanks Adam!

To your success,

Dele
### Inventing: Overrated.
URL: https://deletosh.com/writing/inventing-overrated/
Last updated: 2024-03-01T17:26:36.000Z
## How to “model” success instead

Inventing is overrated. What you need is a framework to re-invent.

Here’s the catch:

Think in terms of what others have done that you can model. A model that you can use as a blueprint for your innovation.

Here are some relevant frameworks:

1. Can you do it better and cheaper. An example is Netflix, Uber, and Airbnb.
2. Can you save users money in unexpected ways.
3. Can you insert your products into your users’ way-of-life. Think the adoption of TikTok in US (*I’m still trying to figure SnapChat, thank you!*).
4. Can you build faster, cheaply and better.

## How

![](https://deletosh.com/app/uploads/2024/02/Amazon.com__the_business_model_book_2020-11.png)

To your success,

Dele
### How to Invent Anything, Simplified
URL: https://deletosh.com/writing/how-to-invent-anything-simplified/
Last updated: 2026-02-28T20:22:25.000Z
### How to Create Luck like its Paper

There’s an untold secret to inventing and innovating things — it’s often a remix. The trick is figuring out what you can remix.

Let’s pick an example: a book you read recently. I’m sure you will want to thank Gutenberg for inventing the ability to print. Not so quickly, my friend.

Gutenberg showed up in 1440 but the first evidence of printing was as early as 200 BCE. That’s almost 1,600 years earlier. And of course, there’s been several remixing between that time.

Then Gutenberg got lucky…. oops. I meant revised it.

Here’s the key:

Looking for things you can remix and bring anew. With proper timing, you get lucky.

## How

![](https://deletosh.com/app/uploads/2024/02/Amazon.com__scot_how_ideas_happen_2020-10.png)

## What I’m Enjoying Lately

![](https://deletosh.com/app/uploads/2024/02/Amazon.com__Alchemy_The_Dark_Art_and_Curious_Sc.png)

Yours in the search,

Dele
### The COVID Void
URL: https://deletosh.com/writing/the-covid-viod/
Last updated: 2024-02-25T17:48:04.000Z
## What are your hidden opportunities?

COVID has thought me an important lesson.

Everything can turn around in a snap. It is teaching me to play and think defensively.

The good news is, in unusual times, the market creates vacuums, vacuums that are filled by opportunist — like you.

Here are some interesting vacuums opening in the market:

- Rise in remote work (this might be the new normal)
- Rise in virtual experiences
- Rise in “realistic” online shopping
- Increased availability of \[Free\] Open Source Solutions
- Rise of Virtual friends and the emergence of closed-small-networks
- Rise in contactless commerce

## How

![An Old Solution to a Modern Problem](https://deletosh.com/app/uploads/2024/02/Amazon.com__maximum_money_with_minimum_customer.png)

An Old Solution to a Modern Problem

## My Favorite Article This Week

[November: A Month for Gratitude](https://www.becomingminimalist.com/november-gratitude/?ref=deletosh.com)

To your success,

Dele
### When is the Right Time?
URL: https://deletosh.com/writing/when-is-the-right-time/
Last updated: 2024-02-21T14:55:12.000Z
## How to predict a market’s future

The usual advice you get when building something new is, “just do it”. How about if you can look into the future and know if what you’re doing is any good?

Let’s take an example:

Say I want to get into the meal kit delivery business like [HelloFresh](https://www.hellofresh.com/?ref=deletosh.com). Let’s see what my chances of success are. I go to [trends.google.com](https://trends.google.com/trends/?geo=US&ref=deletosh.com) and type in “meal prep kit”:

![Interest over 5 years in US](https://deletosh.com/app/uploads/2024/02/meal_prep_kit_-_Explore_-_Google_Trends_2020.png)

Interest over 5 years in US

Interesting.

This is a good sign. In about 2 minutes I can see that this market is steadily increasing. An excellent sign of longevity and future money for you.

This is a market I should investigate more and start doing my other prep work/

By comparison, let’s say I’m trying to build an app for the famous “fidget spinner”. That looks like this:

![Interest over 5 years](https://deletosh.com/app/uploads/2024/02/Fidget_spinner_-_Explore_-_Google_Trends_2020.png)

Interest over 5 years

Run far. Very far!

You get the gist.

Understanding and timing the market brings luck.
### How To Be Great like Bill Gates, Steve Jobs, and others?
URL: https://deletosh.com/writing/unlike-greatness/
Last updated: 2026-02-28T16:14:19.000Z
## Here’s the untold secret

[I found this](https://qr.ae/pNkOuA?ref=deletosh.com) remarkable and want to share.

**Donald Trump** was once asked how he became a **billionaire**.

Most expected an answer long and sour, but Trump kept it short and sweet: “**EVERYTHING** in life is **LUCK**.”

And here’s the truth about “greatness”

---

#### A Word from Fellow Animals

The lab rat is dumped into the “greatness” maze at **birth.**

From the rat’s perspective, he knows not whether a *mad scientist* or a *tree* or a *breeze* was responsible for the grand appearance. …

This rat **born** in the *greatness maze* appears **free** to roam as he pleases . . . go here, go there. The rat even makes plans to **freely will** into existence his great plans!

Here’s the catch: **the rodent is strictly forbidden from ever leaving the confines of the maze!**

Given that the maze has a distinct design, That is, paths interconnected so as to influence the rodent’s behavior—the rat **dies** without ever having escaped the maze.

Such is the true nature of **the greatness maze**!

---

#### The Truth about the Greatness of Bill Gates, Elon Musk, Jeff Bezos and co. .

**Bill Gates** was born into a family of prominence!

His father was **one of the best lawyers in the nation**; his grandfather was J.W. Maxwell—**the president of a national bank**.

And so, in the late 60s, while the rest of the world had never even heard of the word “computer,” aside from its original meaning—*someone who computes*—the same can’t be said for the **privileged** Gates.

**Why?**

His **wealthy** parents enrolled him in the **exclusive private school** Lakeside. And it was at this school where **wealthy members** of the Mothers’ Club pooled together money to buy a block of computer time for Gates.

Even Gates couldn’t help but admit:

For us today to truly appreciate how **rare computer access was in the late 60s,** imagine if a handful of people today already had **access to self-driving cars. …**

Conversely, what if Gates had been born to parents who lived in a rough & tough ghetto on **Chicago’s Southside**?

Would Bill Gates have become the “great” computer whiz we know him as today?

Or would he simply have become “Bill from the hood?”

**What about Jeff Bezos?**

Bezos grew up in the **extremely wealthy River Oaks** neighborhood, a few blocks away from the estate of former president George H. W. Bush.

For the above reason, Bezos—armed with an Ivy League education—thought nothing of it when his parents **loaned him $250,000** to ensure his fledgling Amazon business stayed afloat.

Imagine:

Jeff Bezos had been the child of **poor farmer in rural Alabama**?

Would he still have had those “loaded” parents to help him get Amazon up and running?

**Elon Musk’s** mother was a *famous model*.

As for teaMusk’s father?

He was an *electromechanical engineer . . . a sailor . . . a pilot* . . . a true *Renaissance Man!*

And so, when Elon said:

I couldn’t help but think: “Elon, I’m sure you could **count on more than one hand** how many times *Lady Luck* has smiled favorably upon ya!”

**Steve Jobs’** life has been well-documented and hence you don’t need me to recount his tale of “fortunate” breaks.

From the other *Steve* (Wozniak)—the true “brains” behind designing the Apple products, to having “coincidently” grown up in what would become **Silicon Valley**, it all just seemed to perfectly “fall in place” for ol’ Steve!

Even Jobs had to admit:

As for **Richard Branson**, another son of a **prominent lawyer** and—get this—grandson of an **extremely influential** judge. …

And so, unsurprisingly Branson in all sincerity admitted:

I’ll close this section by **honor**ing Branson’s grandfather, Your **Honor** Judge George Branson:

---

#### Summing things up

The Delphic Oracle crowned **Socrates** the “**wisest** man in Athens.”

Socrates in turn justified the title by noting:

To “control” something is to **exert influence over it.** But, ponder this:

We’re all flung onto the world’s stage and never get to choose either our **birthday or death-day**.

Think about it. …

And so, given the state of affairs: at which point does any mortal—caught swinging on the pendulum between the two extremes, *birth and death*—ever get to **exert influence over events?**

According to biology, each fertilized egg—upon conception—contains **all the genetic information** that results in our *height, race, gender* and so forth.

Clearly, then, the genotype lies outside each of our capacities to exert influence over it.

Clearly everything from the *genotype* to the *phenotype* lies beyond mortal control. …

For the above reason, when the press attempted to shower **Einstein** with the title “**genius**,” he abruptly set them straight:

In short, as **Abraham Lincoln** once noted: “You can fool all the people some of the time, and some of the people all the time, but **you cannot fool ALL the people ALL the time**.”

This notion that these billionaires became “great” because they’re somehow “special” . . . **I’m not buying it with their money**!

And neither is science nor is religion buying it!

And neither should you, my fellow reader …
### Everyone wants to Code. Not You.
URL: https://deletosh.com/writing/everyone-wants-to-code-not-you/
Last updated: 2024-03-01T17:26:55.000Z
If you are to start learning to code today, it’s overwhelming but don’t worry, there’s a simpler alternative: don’t learn to code.

Here are two alternate paths:

- “No Code” and
- “Coding is plumbing”

The core to both of these ideas lies in focusing on the hardest bit of today’s business, figuring the problem you want to solve. Coding comes a distant second.

Well, you have to code at some point but you don’t know how to code? That’s a smaller problem — **build a no-code MVP**.

Your MVP is working our great and you’ve reached the limit of what it can do? “Plumb” your code together using many great frameworks (a secret in software is, no-one ever starts from scratch). This requires more investment in time but then, you’ve confirm (with you MVP), it’s worth it.

### How?

![Building Apps with No Code](https://deletosh.com/app/uploads/2024/02/The_best_way_to_build_web_apps_without_code__Bu.png)

Building Apps with No Code

Think I’m joking? Here are [several apps](https://bubble.io/showcase?ref=deletosh.com) built on Bubble.io

Have a great week ahead!

- Dele
### This Growth Channel Beats Social Media by 3,800%
URL: https://deletosh.com/writing/beats-social-media-by-3800/
Last updated: 2024-02-25T17:48:11.000Z
## How can you tap into a sustainable growth channel?

For what to focus on fueling your organic growth, the choice is often between email and social media.

The winner is Email. By far.

Dele are you nuts?! It’s 2020, who still uses email. Hold my pen friends, let me share some recent research from [Hubspot](https://blog.hubspot.com/marketing/email-marketing-stats?ref=deletosh.com):

- There are 3.9 billion daily email users
- **Mobile opens account for 46 percent of all email opens.**
- 35% of business professionals check email on a mobile device.
- **73% of millennials prefer communications from businesses to come via email.**
- Marketers who use segmented campaigns note as much as a 760% increase in revenue.
- **35% of marketers send their customers 3-5 emails per week.**
- 78% of marketers have seen an increase in email engagement over the last 12 months
- **80% of business professionals believe that email marketing increases customer retention.**
- 59% of respondents say marketing emails influence their purchase decisions.
- **Marketers who use segmented campaigns note as much as a 760% increase in revenue.**

That’s all nice but here’s the ultimate bomb-shell:

You get [$38 for every $1](https://www.emailmonday.com/dma-national-client-email-report-2015/?ref=deletosh.com) spent on email. That’s a 3,800% return-on-investment!

Despite the hype, social media does not come close! If you’re not using email to reach your potential clients and users, you’re loosing out.

**What does this mean for you, your product and business?**

Spend most (or all if you can do just one) of your energy on email as a sustainable growth channel.

## The How

![Damn Good Advice for Email Marketers](https://deletosh.com/app/uploads/2024/02/Amazon.com__Damn_Good_Advice_for_Email_Marketer.png)

Damn Good Advice for Email Marketers

## My Favorite Read This Week

[How To Remember Anything Forever-ish](https://ncase.me/remember/?ref=deletosh.com)

There are things you want to forget for life. For those not in that category, this is a step-by-step walkthrough on spaced repetition.

## What I’m Currently Reading

![Successful Innovation Outcomes in Law: A Practical Guide for Law Firms, Law Departments and Other Legal Organizations](https://deletosh.com/app/uploads/2024/02/Amazon.com__Successful_Innovation_Outcomes_in_L.png "Successful Innovation Outcomes in Law: A Practical Guide for Law Firms, Law Departments and Other Legal Organizations")

Successful Innovation Outcomes in Law: A Practical Guide for Law Firms, Law Departments and Other Legal Organizations

---

> People will quit on you. You gotta get up every day and make sure you don’t quit on yourself.

Yours in the Hustle,

- Dele
### The NPF Method: Building A Client-First Legal Product
URL: https://deletosh.com/writing/the-npf-method/
Last updated: 2024-02-22T22:12:38.000Z
Regardless of what you know about computers or software, here’s one thing I can assure you:

Today, building a software-based business is easier than ever. 

I know, I know… you don’t believe me \[yet\] and that’s OK. 

In this guide, you will soon learn why that is. I will walk through a framework for building your first tech product even if you don’t know how to write a line of computer code (or never seen a computer before — wait… how are you reading this?).

First, a small secret — most people fear getting into the tech because they fear they can’t write code or don’t understand all that technical stuff. 

The shocker: 

When it comes to building a tech business, none of those matter very much.

That’s some good news!

If you missed it, let me repeat, building software today \[as a business\] has gotten easier, much easier. And before you go out celebrating, let me still clarify:

Building software is hard, but you know what’s harder:

Finding a business that people will PAY for…

That, my friend, is HARD.

Very hard.

Luckily, that’s what this guide is about. 

I will show you an alternative approach to building a tech business starting from this very hard place — getting people to pay for your product before you even build anything.

## The Crushing Game Plan

Here’s our game-plan:

1. Start with the VERY HARD stuff (i.e. getting a business people will pay you for).
2. Build a technical, software-driven solution.

A clarification: 

When I say “technical” or “software-driven”, I’m referring to a business that relies on technology to deliver value. It can be a mobile app, a web app or some other fancy things like API, AI, blockchain, etc.

For now, none of those matter, we will get there, but not until we get our foundations set — doing the very hard stuff.

## The 6-Step Framework

When you set out to build a tech business, there is always the temptation (especially if you’re technical) to start with building a solution; your solution to what you think will be the fit to the problems people are having.

**STOP!**

Let me introduce you to a new way of thinking about building your business that will save you heartaches.

1. Apply The “Nigeria Police Force” (NPF) Method ? Most important
2. Pre-sell
3. Build Loyalty
4. Build “It” ✋ the wrong place to start
5. Build More Loyalty
6. Profit

Let’s dive into the details.

### Step 1 : Apply The “Nigerian

 Police Force” (NPF) Method

Think about this:

![](https://static.authoritywit.com/shots/productick_npf_NPFMethod_1.png)

I’m sure we can both agree that everyone has problems, your singular job as an entrepreneur is finding all those problems, crafting a solution and delivering it to the people.

It’s really that simple.

The problem is, it’s not so simple finding problems people have, (and strangely, all the advice you get seem to skip this point) you have to hunt for it, and be sure there’s enough value they will pay for.

This is where **Nigeria Police Force (NPF) Method** come in.

To the uninitiated, there’s a lovely city in West Africa, Nigeria called Lagos. When I started driving around Lagos I started noticing a pattern:

1. There’s a lot of armed men often stopping your car and asking for “stuff”
2. They all seem to ask for the same stuff, the same way — never, ever being direct.

The conversation will go something like (in Nigerian Pidgin English):

“Well done, oga, wey your particulars?” (*Hello, where’s your \[vehicle\] papers*). You provide that.

He continues, “wey your safety triangles and fire extinguisher”, you show that. He’ll keep asking about other random \[car\] things, until he says something like, “Oga how far nah, you know …” (Sir, you understand…). 

Any person who has spent sometime in Nigeria immediately understands this “code word”, pay “the tax”.

Here’s the insight: 

They \[the NPF\] never actually come out and ask you what they REALLY want, they keep asking around it, and that’s the core of the NPF method:

1. The NPF first identify their target; you, an entrepreneur must first identify your customers.
2. The NPF talk about (and around) their target’s problem and/or try to agitate it; you, an entrepreneur must talk to your customers, about their problems (NEVER about your solution no matter how tempting) and try to agitate/dig very deep to mine their truth.

The premise is: 

You talk to people (your \[identified\] prospective customers) about what you want (finding out if your idea is any good) without actually stating your intent (building a solution to sell to them).

Here’s the framework:

The biggest mistake that many entrepreneurs make is defining the solution before they have: 

- Understand who their customers are.
- Spoken to these customers (those that will pay them).
- Understand the problem, from their customers point of view.

Sadly, many jump right to building out a solution only to discover when it’s too late that unfortunately, no one cares.

Let me repeat, the “building” should come much, much later. 

The key thing is:

When you get your idea, talk to people you suspect might be your customer, have great conversations with them, and like the Nigerian Police Force (NPF), don’t bias them with your \[supposed\] solution. Get the front-row point of view of your prospective customer’s problems.

Here are some things to keep on mind as your go through this method:

- Everybody lies, even your friends. Put them to “The NPF” method. People lie when they think it’s what you want to hear
- People often know their problems but not how to solve it
- Don’t trust what people tell you, watch what they do—this is where you find the bottlenecks, i.e. your opportunities.
- If people haven’t found a walk-around to solve the problem in the past, they won’t care for your \[new\] solution.
- Fixate on your prospective previous behaviors, it’s a superb predictor of the future.
- No one lies when you ask for cold, hard cash.
- When you watch hard enough, you can find what your solution is worth to people
- Never obey people’s “ideas” (especially when they are not paying), get to understand their intent.
- Talk less, listen more — in fact, the more you’re talking the less you’re learning.
- When you’re rejected, its good news! It’s an opportunity to learn, better.
- Don’t get stuck in the weeds, always have your eyes on the bigger problem.
- Keep your learning casual, the more formal, the more opportunities for lies.
- Be careful with people who don’t give definitive responses. They waste time and give little insights. You want your prospects to be firmly on one side of the fence or the other.
- Give people the chance to reject you — its good news.
- Find opportunities to chat about things you and a potential cares about, you learn, they enjoy the conversation.
- Always be having conversations until you stop hearing something new.
- If you’re not not finding consistent problems, pain, and goals, you might have to pivot.
- If you can find up to 30 people, try to get 50% + (about 16 people) to validate your idea.

### Step 2: Pre-sell

You’ve gone through the “NPF” method and gotten good results? Congrats, you’re getting closer.

Let’s push things further:

Once you’ve spoken to some prospective customers about the possibilities of them using your solution, before you run off to start building, let’s narrow things down with these two things:

1. **Build a Landing Page of your “product” (\~1 hour)** If you’ve spoken to enough prospective customers, you should know what your unique selling point is.

To test the viability of your idea, build a product landing page that clearly states that selling point. Don’t spend too much time on this. Depending on your level of skills, there are several landing page builders, search and pick one that matches your skill level.

At this stage, you design that landing page to be as close as possible to a finished product with a clear call to action (as you would in your finished product). You want to measure if people resonate with your message and your interpretation of their problem and proposed solution (your value proposition).

1. **Drive traffic to your landing page. (\~2 hours)** Use paid media like Facebook, Bing, or Google Ads to drive people from your NPF to this page (and others like them).

Only use free source (like Social media) if you cannot afford to use paid media.

What you’re looking to get at this stage is some commitment (i.e. asking for their email/phone number, asking for a down payment, etc).

Please, don’t spend too much time at this stage because you will iterate through a few ideas to truly getting to validation.

![](https://static.authoritywit.com/shots/productick_npf_Pre-Sell.png)

Your cycle will look something like:

### Step 3: Build Loyalty

If things are working well in your favor, you will now have a few that will give you some commitment. The value of commitment will be relative. You’re the best judge of what will be significant to you.

If you gotten something significant, proceed through this stage. If not, go back to the previous section. 

Here’s how the flow looks:

Don’t worry if you’re not set to proceed, go back to the previous section and iterate.

Early stage customer loyalty is extremely important, building this loyalty before you even kick-off any solution.

Through the campaign you’re running to send traffic to your “product” page, these is a great oppurtunity to practice building those relationships.

Truth is, you are new, no one cares!

They \[future customers\] must trust you; give value and build an “expertise” in your business niche.

Here are things to try: 

- Giveaways
- Blog posts
- Follow-up emails
- WhatsApp/SMS Messages follow-ups

### Step 4: Build Your Product

Now the part we all love, the “easy” bit:

Build your tech product…but WAIT!

If you already know how to build your software, congrats. 

If you don’t, no need to worry, In the following section, we will go through the key things that you need to know.

A strong word of caution:

Unless you’re already a skilled developer, I recommend you have someone else build the solution. Your core task: work on building your customer-base, selling and marketing your solution. 

As an entrepreneur, this is the best investment of your time. Regardless, you still need to understand the tech jargons. 

So here we go:

#### Business Models

Here’s the more popular business model for tech companies:

- Software-as-a-Service (SaaS): You charge a subscription to use your software/app. It’s the sweet spot for a technology business; you get that sweet recurring revenue.
- Licensing: You charge a fee to use your product, often a onetime fee.
- Freemium: This is a sibling to the SaaS model, in this case, there is a free version of the paid product (think Dropbox) that you hope users will eventually upgrade to the paid version. This model is attractive but can be hard to get users to upgrade. Not beginner-friendly or the faint of heart.
- Free-As-A-Service: Your product is free and you find other ways to monetize, often through ads or professional service.

##### Platform: AI Development

If you’re interested in artificial intelligence, here are some platforms you should know about:

- Amazon Web Services: forecast, recommend, insights, analysis, transcribe, etc
- Google Cloud Platform: Vision, Video, etc
- Twilio (Bots): SMS bots, WhatsApp bots, telegram bots, etc.
- ManyChat (Bot): Facebook Messenger bots

##### Platform: Web Development

In web development, there are several platforms/technologies that you might want to build on, I’ve narrowed it to a few:

I often divide the platform into:

- Front-end: the part of a website you see and use. As of this writing (this tools evolves so fast), here are the top options:  
  - VueJS
  - AngularJS
  - ReactJS
- Back-end: the “invisible” section of the website. These are the most beginner friendly in order of difficulty.  
  - Firebase
  - Strapi
  - WordPress
  - Laravel
  - Ruby on Rails

##### Platform: Mobile Development

In mobile development, things have gotten simpler, it’s iOS or Android. 

- Android – Kotlin/Java
- IOS – Swift
- Android + iOS: Flutter / React Native (If you’re going this route, I strongly recommend Flutter)

##### Outsourcing Development

Just in case you missed it, let me remind you: Don’t build a software solution from scratch IF you can afford not to (even if you’re an experienced developer). Get help. 

Hire a developer: 

- Upwork
- Fiverr

Buy Source Code: 

- Mobile (React Native): https://market.nativebase.io
- Web and Mobile: https://codecanyon.net/
- Web: http://themeforest.com

#### Financing Your Solution

I know you might have the question, how do I pay for things if you keep asking that I not do it myself?

There are a few ways to finance the solution you will build. As an entrepreneur, your greatest asset is your time and you should always consider your time more expensive than the money. This means, if you can pay for more time, do so and spend your time, generating more money.

Here are the key source for finance, in order of preference:

1. **Your Personal Savings**: Most ideal.
2. **Blood, Sweat & Tears Equity**: If you don’t have enough personal savings, you might have to learn, and build and be willing to do the work AND/OR find other willing to do the work for a share of the business.
3. **Friends, Family & Fools**: If all else fails, seek out family, friends and fools, tread carefully. This should be least preferable to the others.

### Step 5: Build More Loyalty

Customer Service is KEY. Don’t hide, be personable to your customers, entertain them. No customer, you die, treat them well!

### Step 6: Profit

Obviously!

Keep an eye on that cash-flow! That is, learn finance and understand how the numbers works. 

(See my reading recommendations below).

## Crushing Your Devil

Regardless of what you may know or how confident you are, if you don’t execute, nothing happens. Let’s walk through a framework for deliberate execution.

- Have Quarterly goals (4/year) — what are the “big things” you want to accomplish in 1 year? 3 months?.
- Break your quarterly goals into:  
  - Monthly Goals
  - And, your monthly goals into Weekly goals
- Block out time every week to review your weekly goals.
- Make a daily list and do it with the [Pomodoro technique](https://en.wikipedia.org/wiki/Pomodoro%5FTechnique?ref=deletosh.com).
- Do the HARD things first.
- Give back a.k.a. be intentionally generous. It’s not always about you.

### Apps for Success & Discipline

Use these apps religiously (All free): \* Google Calendar \* PomodoneApp or Focuslist (Mac) \* ClickUp

## Skills You Must Have

When building a tech business, much might think that the topmost skill to have is how to write code, or how to understand technical jargon, or how to know the latest technological fads.

All wrong.

The topmost skills you must have are:

- **Sales**: knowing how to spot problems, what makes humans tick and pay to remove pain.
- **Marketing**: knowing how to position your solution for optimum impact.
- **Writing**: knowing how to communicate yourself at scale.
- **Entrepreneurial Finance**: knowing the key numbers that move the needle.
- **Organizational Intelligence**: knowing how to manage your own shortcomings and getting the right team. You can’t do it all!

If you don’t have these skills yet, see the resource section on books to learn, it’s a must.

No matter the next technological evolution or the next new things, as long as you’re dealing with humans, the above will be what will set your solution apart from the crowd.

## Resources

Here are my recommended reading to get your mind and skills in the best shape for business battle (in no order of preference): 

- Radical Focus: Achieving Your Most Important Goals With Objectives – Christina R. Wodtke
- Kick-Ass Copywriting Secrets of a Marketing Rebel – John Carlton
- The Toilet Paper Entrepreneur: The Tell-It-Like-It-Is Guide – Mike Michalowicz
- Brave Bootstrapping: How to Grow a Global Tech Business Without VCs – Sarah J. Perry
- The Entrepreneur’s Guide to Getting Your Shit Together – John Carlton
- Claude Hopkins Scientific Advertising – Carlo Galetti, Claude C. Hopkins
- Breakthrough Advertising – Eugène Schwartz
- Ogilvy on Advertising – David Ogilvy
- How to Build a Business and Sell It for Millions – Jack Garson
- The Mom Test: How to Talk to Customers & Learn if Your Business – Rob Fitzpatrick
- Simple Numbers, Straight Talk, Big Profits! – Greg Crabtree & Beverly Herzog
- Everybody Writes: Your Go-To Guide to Creating Ridiculously Good Content – Ann Handley

If you’re wondering why I included no book on a specific technology, let me clarify again: this is a guide on building a business not on writing software or using technology.

To an entrepreneur, technology is a means to an end, not the end itself.
### The Ultimate Quick-Start Guide to AI, Machine and Deep Learning
URL: https://deletosh.com/writing/machine-deep-learning-guide/
Last updated: 2024-02-21T16:37:10.000Z
If you ignore the role Artificial Intelligence plays in today’s business landscape, you’re doomed.

Despite the general awareness of AI, many often forget that you can’t just hire a couple of data scientists to make inroads in the industry. 

Here’s the small secret: 

Data scientists are good at working on machine learning, statistics, and finding patterns in data. However, they might lack the decision-making skills of a business leader — this is still required to create a production-grade system.

As a decision-maker, you need to be aware of the patterns found in the data and turn this into insights that you can use in your business. This is now the new normal. 

In this article, I walk you through everything you need to know in the world of artificial intelligence without any of the usual technical jargons.

Let’s dive in.

## **What is Artificial Intelligence (AI)?**

Artificial intelligence is a science that describes the computer technology, which makes it possible for computers to think and act like humans. It can also be described as the ability of a machine to perform cognitive functions that includes speech recognition, planning, learning, interactive, and problem solving, among a variety of other tasks.

Some of the most popular examples of artificial intelligence are automobiles without drivers that can interact with the environment just like a human driver. Less technical, but equally important examples are a variety of automated robotics tool that help build automobiles in the factory.

### **Artificial Intelligence—A Very Brief History**

You should seriously think about adapting artificial intelligence because human race is at an important junction of a technological breakthrough. To understand this transition, we need to look at the history back to 1805 when Legendre laid the groundwork for machine learning. However, its widespread use did not become possible until 1991 after the introduction of the Worldwide Web. Since then, the Internet has resulted in the explosion of data, which helps explain the recent growth of artificial intelligence.

Today, we are at an important crossroads in history of computing because the three powerful components of artificial intelligence—explosion of data, algorithmic advancement, and an increase in computing power—have become a reality. In fact, the groundbreaking advancement in the field is attributed to the confluence of these three components.

While computing algorithms had already started to take shape as early as 1805, an exponential increase in computing power was only made possible in 1965\. In 1965, Intel cofounder, Gordon Moore, discovered that there will be an exponential growth in chip power every few years. Later, scientists confirmed his theory, called Moore law, confirming that the power will roughly double every 18 months.

The introduction of Internet paved the way for a union of these three components. Experts often believe that the confluence of these three vital components in artificial intelligence was reflected in 2009, when Andrew Ng and his team at Stanford, discovered that GPU can process the data much faster than a typical CPU, used in modern-day computers. According to his research, GPU can be used to train deep-belief networks 70 times faster than a typical central processing unit. As a result, machine learning can theoretically improve 70 times than what was originally thought.

In 2017, Google introduced TPU, tensor processing unit, which is reputed to be 10 to 30 times faster than GPU. It will be offered through Google cloud based services, in the near future. Overall, it means that the next four to five years are crucial to the success of companies who have an opportunity to become early adapters of a technological breakthrough in human history.

## **What is Machine Learning (ML)?**

Any discussion on artificial intelligence starts with the basics of machine learning models. These models are the foundation of AI, and you must understand these terms to make a viable decision.

![](https://productick.com/app/uploads/2019/03/productick-ai-ml.png)

Remember: Machine learning is a smaller subset of AI.

The theory behind machine learning involves training robot and machines to respond to events based on the available data and past interactions. Initially, machines are given large amounts of data to learn and understand patterns. Using the data, these machines predict and recommend things to do. In fact, artificial intelligence has evolved to an extent where the machine is able to learn and improve from new sets of data and its interaction with the environment, based on previous actions.

### **Machine-Learning Models**

There are usually three machine-learning models used in the industry. The most basic is descriptive mode, which describes what and how things have happened. Despite its simplicity, it is an important part of the machine learning process because it can provide useful insight to humans enabling them to improve their productivity. Nowadays, descriptive machine learning model is deployed in many industries around the globe.

A more advanced version of this model is the predictive technology, which predicts future events based on the probabilistic theory. The model is specifically useful in data-driven industries that rely heavily on probability, such as casinos and lotteries. The most advanced of the three machine learning models is the prescriptive model. The model not only provides information of how things will shape in the future, but it also recommends what and how to do it. Often robots and machines used prescriptive model of artificial intelligence so they can make independent decisions.

### **Types of Machine Learning**

#### **Supervised Learning**

It is the simplest of AI models based on the input and output modes. The system learns the relationship between input and output from an extensive set of data. Based on the data, it finds a correlation between input and output to generate a sample or an outcome of an event. Examples of supervised learning is vastly used in academic and research. Examples of the model include algorithms such as linear regression, naïve bayes, random forecast, and decision-tree, among others.

#### Unsupervised Learning

This is an advanced version of the original system, which only requires an input to work. Using data input, the system generates a set of patterns to automatically produce an output. It is mostly useful in environments where the user has to work with a jumbled cluster of data or where the data does not make any sense. For instance, a user may get millions of different set of numbers regarding customer interaction with different products in the super store. Using unsupervised learning models, the researcher can classify random data in specific groups, which are easy to understand. K-means clustering and Gaussian mixture model are examples of unsupervised learning.

#### Reinforcement Learning

This system learns from its environment by reinforcing its actions. It is used in an environment where the only goal of the user is to improve the existing result. Reinforcement learning is used when researchers don’t have a reliable set of training data, and they are unable to define the ideal state. As such, the algorithmic model performs a task with the sole objective of getting a reward for improved results. The cycle continues infinitely, or until the user is satisfied. Business use of the reinforcement model is clearly evident in the functioning of option-trading portfolio, self-driving cars, auctions, and load-balancing for electricity grids.

## **Diving Deeper Machine Learning to Deep Learning**

![](https://productick.com/app/uploads/2019/03/productick-ai-ml-dl.png)

Deep Learning is another subset of Machine Learning

In today’s business environment, you will definitely come across AI models featuring deep learning. In simple words, these are advanced models of machine learning you must learn to oversee future projects.

Mostly used to perform complex functions, deep learning requires a massive amount of data to process. As explained earlier, the introduction of Worldwide Web and related technologies have allowed us to process data on an epic scale. As the new data becomes available, deep learning will also continue to improve.

The most significant difference between deep learning and machine learning is based on the presence of a large number of inter-connected layers in deep-learning models. The model uses multiple neural networks to share and understand the given data. At each level of the entire system, multiple stand-alone networks independently process data before sharing it with other networks. It also means that deep learning often involves separate decision-making process to understand and implement the data before making a coherent decision.

When compared to machine-learning methods, deep-learning can easily reduce error rates to improve the productivity. Research shows that there is 41% reduction in errors for image classification using deep learning. Likewise, errors are also reduced for facial and video recognition by almost a quarter.

## Types of Deep Learning

#### Convolution Neural Network

The system can be described as a multi-step linear model, which uses many neural networks to process data at each step. During each stage, complex features of data are extracted to provide a powerful output. This model is mostly used where only unstructured data, images, and visual clues are available for processing. Facial recognition is the most common example of the model.

For facial recognition, the system processes series of pixels. At each step, it may identify and verify unique features of different clusters of pixels to create an output. Comparing the output with the original data, it identifies the image. Later, it can reinforce its learning using the previous output. Business use case of this model includes health diagnostics from medical scans, detection of defective products, and understanding customer’s brand perception using images.

#### Recurrent Neural Networks

When researchers are working with a time-series or sequential data, recurrent model may offer the best solution. It is composed of a multi-layered network that uses context nodes in different locations. Each node is able to store complex information enabling it to react with other data clusters when required. It is increasingly used in business scenarios involving language translation, verification of credit cards, and power chat bots.

## **Applications of Modern AI Techniques in the Industry**

If it’s your first time implementing the technology, focusing on three main areas of AI will help reach your goals quickly. Here is an explanation of these three critical areas:

### Core Business

A recent Infosys report indicated that 73% of C-level executives confirm they have implemented some form of artificial intelligence in their core business. For instance, Morgan Stanley has created an intelligent tool for its brokers, which can easily determine optimal client allocation portfolio using the existing allocation, tax preference, and preference. Using the up-to-date data, company’s brokers can send customized advice to their clients without having to drill data themselves.

In fact, Pfizer is taking artificial intelligence to an entirely new level using IBM’s Watson for Drug Discovery tool. It is the first pharmaceutical company that is destined to revolutionize cancer treatment through machine-learning process. In its struggle to fight cancer cells, IBM’s tool will become the basis of immunotherapy. Immunotherapy is a process that changes the immune system of the patient by recognizing effective patterns of killing the dangerous cells. IBM’s tool with allow researchers from Pfizer to analyze massive amounts generating meaningful insights and safety assessments.

### Human Resource Recruitment & Training

Recent research suggests that nearly half of large companies in the United States have implemented machine-learning to enhance their human resource endeavors. Many companies are using AI to help them pre-screen potential job applicants or evaluate them during the interviewing process. In addition, increasing numbers of human resource managers are using artificial intelligence to train employees. In addition, 62% of talent acquisition companies are planning to invest in AI software in the near future.

Companies such as IBM are using chatbots to engage candidates who it thinks are a good fit for the company. The chatbots is a success as it is helping reduce the time required to evaluate candidates. When BuzzFeed used IBM’s Watson Candidate Assistant on its website, it saw 64% more candidate progress during the interview selection funnel. The AI software is also used by small tech companies like Kore.ai, where in-house chatbots interact with employees to answer common questions and conduct interviews.

### Critical Decision Making

Artificial systems can give support to managers in critical decision-making process by offering data-driven streamlined solution to complex problems. A recent PwC Report found that 62% of C-level executives will use artificial intelligence to improve productivity.

Already, companies are using artificial intelligence to test different hypothesis. For instance, Coca-Cola used AI technology to successfully launch Cherry Sprite. Instead of asking consumers for their preference and taste, Coke used the self-serve soda foundations to collect data from consumers. In this case, artificial intelligence improved results making Cherry Sprite, a successful product launch.

While AI systems are critical to the success of managers, it should not be seen as a replacement for emotional intelligence and adaptability of you, a human.

### **Implementation of Artificial Intelligence**

Despite the technological achievements, you must understand that it will be up to a human to make critical decisions. AI systems are only to help in the decision-making process because even the most advanced systems need some kind of input that only a human brain can provide. Accordingly, here are the things that you need to consider before launching your project.

## Should You Invest in AI?

Implementation of artificial intelligence should align with the business objective and plan. Accordingly, there should be proper planning before rolling out features of the AI to different business sectors. If different departments are involved, careful analysis is required to ensure harmonious transition at multiple levels. Until now, researchers, data scientists, and engineers are mostly involved in the process: however, smart executives will ensure that every person can learn and take advantage of the system in the company.

### Artificial Intelligence and Business Goals

You don’t want to update your existing systems just because AI is a trend. Before implementing AI system in your company, make sure that artificial intelligence will solve the problem. If artificial intelligence cannot increase your productivity, the transition from traditional systems can quickly become very costly. Accordingly, it makes sense to evaluate your goals and the impact of AI before integrating the new technology.

Once you are ready to implement, always try to test it on small-scale projects before going mainstream. Despite their reputation, successful companies such as Google, Microsoft, and Intel are known to test new technology on a much smaller scale before upgrading to the next level. Even if your intuition tells you that you can resolve problems after implementing AI, it helps to reevaluate the urge to integrate AI. you need to be cautious because any large-scale modification in the system can disrupt the working and can often prove irreversible.

### The First Steps

There are many simple tasks that are time-consuming due to the traditional setup. These repetitive tasks can be solved using AI. As machine learning has intensified, AI solutions are increasingly becoming a part of the back-office functions, which includes accounting, IT support, logistics, and operations.

Before overseeing such tasks, you also need to understand the basics of artificial intelligence. It is not uncommon for many executives to take training in natural language processing and machine learning technology. Learning these modules will definitely help in decision-making once you hire trained professionals who are working with seemingly complex patterns such as data-mining, writing algorithms, and trend-detection. Without the basic knowledge of AI, you will be hard pressed to make your own decisions.

As discussed, most AI projects start with a small task; therefore, learning AI will also help executives take charge of small setup. By overseeing and managing small modifications, it will be easy to grasp the full potential of the system, and come up with grand ideas. It will also be easier for employees to keep their focus on the project without losing sight of the core operations.

#### **Understanding Artificial Intelligence and Business Landscape**

If you have made up your mind to take charge of the proceedings, don’t forget that successful implementation of AI models also requires three fundamental capabilities. From the perspective of machine learning business ideas, these three capabilities are data unification, real-time insight, and business context.

#### Data Unification

The soul of artificial intelligence is the data, which needs to be unified in an understandable format. Before the widespread use of artificial intelligence, collecting such data was a laborious task as companies often had to spend hundreds of man-hours pursuing the data. As technology progressed, numerous data service providers emerged that offer streamlined solutions for companies.

For e-commerce businesses, Clickstream data is an example of data unification. It allows decision makers to analyze the click path of customers while browsing the website. Similarly, there are numerous customer journey analytics platforms that can offer important data free of cost.

#### Real-Time Insight

Raw data cannot help a business increase its productivity unless you are able to get real-time insight into the behavior of a consumer. As a first step towards artificial intelligence, you need to understand types of data that is used in AI systems.

After deciding which data to use, you must decide how they are going to decipher the information. These days, plenty of data analytics software provides artificial intelligence to gather and respond to a customer at every touch point of their buying journey.

For instance, Capillary offers a retail analytic solution to better understand consumer behavior. Businesses can integrate Capillary’s system to capture in-store data and gather information from hundreds of different touch points. The end result is a single-view of the behavior of the consumer as they pass and interact with different touch points.

Real-time insight helps yous understand the psychology of consumers enabling them to engage customer at the right moment of their shopping experience.

#### Business Context

Gathering the data and engaging customers at various touch-points is merely the start of a potential positive relationship; however, businesses can only succeed if artificial intelligence can guide the consumer in the right direction without human intervention. The final part of a successful AI implementation is the business context. Business context can be defined as a cross-platform journey that can produce mutually beneficial results for consumers and the business.

It also means that humans only need to work in the background to improve customer-interaction and let the computers dictate the best path. From a business context perspective, the success of such a system is determined after evaluating productivity and other success parameters.

## **Buying vs. Building—Machine Learning Applied**

When it comes to making the decision to buy or build AI system, you should base their decisions on the potential success of the project. In addition, take control the ownership of the system instead of relegating full control to the vendor.

Based on these preferences, there are generally four options for you. 

### Commodities

Most companies prefer this model as it allows them to share their data with vendors without revealing anything that may allow the vendor to grab a competitive advantage. In this model, the company has almost full-control over its database.

Goldman Sachs uses the commodity model to screen potential candidates using artificial intelligence. Its vendor, HireVue helps Goldman Sachs to select preferred candidates based on word choice, facial expressions, and other characteristics. HireVue has over 20 million video profiles, which cannot be replicated by an individual company.

In this partnership model, Goldman Sachs used AI solutions without the fear of losing competitive advantage to HireVue as both companies differ in their respective objectives.

### Hidden Opportunities

Using vendor’s database, companies can access data, which is of critical importance. In this model, companies not only analyze chunks of the data, but they can sell it to others. For instance Woodside Energy gained access to IBM Watson gaining expert knowledge of oil platform operations collected over 30 years by Watson.

Relying on Watson natural language technology, Woodside Energy offered data access to all of its employees. Accordingly, employees were able to construct and interact with data to answer important questions related to the operations. In this scenario, Woodside Energy maintained control over the data without sharing the information with IBM. The end result was massive data that is very valuable to other industry players allowing Woodside Energy an opportunity to sell the data to others.

### Danger Zone

A recent research at Oxford University claims that half of the people in the United States will lose their jobs to artificial intelligence in the coming decade. For you, this is an eye opener because they need to understand that transformation of human resource has started to take place. In order to survive, businesses must integrate AI in their workspace as most automated tedious tasks are actively replaced by technology.

You must understand the dynamics of AI to ensure that you hire most productive workforce that is educated and trained to solve cognitively complex tasks. Understandably, some cognitively complex tasks cannot be relegated to machines; therefore, executives will require a workforce that is able to cope with the advance technology. In fact, the workforce of tomorrow will be trained in STEM, science, technology, engineering, and mathematics. The trained workforce will be your most important asset in collaborating with vendors, particularly if this collaboration is in danger-zone.

Machine diagnostic of radiological images is an example of this relationship where the vendor is able to create a high-quality image library that can be superior to any of the healthcare provider. In such cases, where companies have no choice but to use third-party technology, they should be careful in how much they want the vendor to know about their operations. As a result, a knowledgeable workforce trained in AI will be able to keep the balance in the relationship with vendors. Without investing in AI technology and STEM workforce, you are likely going to lose quickly to more intelligent counterparts.

### Gold Mines

If the company has access to a large database of critical information, it can reliably build its own AI system without sharing control with the vendor. A tire manufacturer successfully used this model to build an AI system that could tell tire vendors about the potential demand of a tire in respective stores. The system predicted the tire demand based on anticipated tire wear from nearly 1.6 billion data points. As a result, sales and productivity increased substantially.

Before following this model, you should ensure that they have a team of programmers and data scientists who understand the nature of the project. In the long run, these employees will be critically important to the company because of their knowledge and expertise in building such a system. Sometimes, it is also better to create a project with other like-minded vendors. For instance, companies in self-driven vehicle market can collaborate together to mine extensive data instead of relying on vendors. This type of collaboration often increases the pace of development.

If you’re still wondering what is machine learning, and how it can help you, think fast because it is estimated companies will dedicate up to 20% of their workforce to AI, in the year 2020\. According to Economist, 75% of executives suggest that AI will be actively implemented in their companies within the next three years. 

Make sure, you are on the losing end. In fact, artificial intelligence is not the future, it’s now.

Now it’s up to up, let me know in the comments your current AI, ML DL challenges.
### A Simple Pragmatic Guide on Learning to Code
URL: https://deletosh.com/writing/learning-to-code/
Last updated: 2024-02-22T22:12:49.000Z
These days, everyone and their dogs want to learn to code — that’s fine, as long as you understand what you’re about to take on. Since I’ve been getting this question a lot lately, here’s my response.

First an important point, sites like [codeacademy](http://www.codecademy.com/?ref=deletosh.com), [treehouse](http://teamtreehouse.com/?ref=deletosh.com), etc. give a false sense of progress, skip those.

If you want to **really** learn to code, you need 3 things: Focus, Determination and a Resource. You bring the first two, I’m recommending the third.

I recommend you start with either **Javascript** or **Python**. One or the other, not both**.** Here are the steps:

1. 1. Get a solid book.
  2. When you’re going through your book of choice, never copy-and-paste. [Zed Shaw](http://zedshaw.com/?ref=deletosh.com) tells it best,”*You must type each of these exercises in, manually. If you copy and paste, you might as well not even do them. The point of these exercises is to* ***train your hands, your brain, and your mind in how to read, write, and see code.*** *If you copy-paste, you are cheating yourself out of the effectiveness of the lessons.”*
  3. Get a mentor or mentors that can guide you and show them short-cuts and untangle them from impending frustrations, there will be lots of it.
  4. Patience, and persistence. It will be tough sometimes, but have your end-goal in mind. It gets easier and better.
- - - You will notice I’m recommending books. If you can, stick to books. Remember, you want to train your mind how to read, write, and see code, books make that even easier.

Go take action, now.
### A Crash Course in Data Science
URL: https://deletosh.com/writing/data-science-crash-course/
Last updated: 2024-02-21T16:37:27.000Z
Almost everyone believes they know what data science is until you ask them what it is:

![](https://deletosh.com/app/uploads/2024/02/01AoOoj3PFSAQyFec.png)

Content

1. [Why Data Science](#why-data-science)
2. [The Complexities of Data Science](#the-complexities-of-data-science)
3. [The Data Science Process and Workflow](#the-data-science-process-and-workflow)
4. [Tools for Data Science](#tools-for-data-science)  
  1. [PYTHON VS R](#python-vs-r)
  2. [TOP PYTHON DATA SCIENCE PACKAGES:](#top-python-data-science-packages)
5. [Top Resource to Learn Data Science](#top-resource-to-learn-data-science)  
  1. [LEARNING PYTHON LANGUAGE](#learning-python-language)
  2. [DATA SCIENCE WITH PYTHON](#data-science-with-python)
  3. [LEARNING PANDAS](#learning-pandas)

## Why Data Science

Until recently data science, and business analysis, were sometimes used interchangeably. In fact, it is difficult for you to distinguish between the roles of a business analyst and a data scientist in a small organization .

In today’s \[business\] world of bigger data and cheaper computing, think of data science as business analysis on steriods, serious steriods.

What is the difference between the two?

Compared to business analysts, data scientists has advanced technical expertise in areas such as system engineering, computer programing, and statistics.

The business analysts depends on human decisions and intuitions that experts are considering inadequate and puts businesses at a disadvantage compared to the data-driven facts data scientists generate.

Moreover, business analysts focus on one perspective, for example, the events that worked in the past. Data scientists, on the other hand, focus on a more fluid analysis, that is, future events.

Data scientists explore and discover patterns that enable business executives in your organization to make big decisions informed by big data. Data scientists enable businesses to utilize large data in executing certain functions and processes, while focusing on performance and operation.

Put differently, data science enables the conversion of valuable data into actual business value.

This entails translating patterns and insights contained in the data into language businesses can understand. Some advanced data science are looking for ways to use predictive analysis to deal with the challenges businesses face.

The main advantages of data science to your organization includes:

- Assisting executives in the marketing and sales departments in understanding the most profitable products based on factors such as season, region and customers among others.
- Data scientists can assist retailers with staffing plans in seasonal businesses.
- Data scientists keep tract of any anomalies or rare explosions in financial transactions that may be a sign of fraudulent activity.
- The analysts also help with the refining of standards and metrics report to meet the needs of the executives looking for support for their decisions.
- Lastly, data scientists perform market research and keep track of external trends that affect specific products such as demographic segments and geography.

## The Complexities of Data Science

The complexities and sides of data science are evident in the three steps of data work that include collection, refinement and delivery of data.

In the collection stage, data scientists often face a challenge posed by the sheer size of data, and this is why most current databases are designed for the rapid collection, storage and retrieval of information.

However, if large volumes of data are collected rapidly, mounds of disorganized data may be generated. Data refinement is needed to make the data usable.

In the process of refinement, data is converted into answers that address specific questions. This means that big data is broken down through refinement.

Data refinement is one of the most crucial steps in data operation because it enables the standardization, categorization, summation, and tagging of data. Data refinement is done through statistical modeling that turns piles of disorganized data into usable answers.

Once data are analyzed to answer specific questions, data scientists make the answers available in proper format through an optimum channel.

Data delivery can be done using different channels depending on the aim of your organization.

It is important to note that the role of data science analysts has changed. In the past, data science was linked to specific technologies and the complex process involved in SQL queries.

Modern data science analysts convert a request for information into questions and models self-serve tools can use. Think of how Google shows you searches only relevant to you

## The Data Science Process and Workflow

![](https://deletosh.com/app/uploads/2024/02/0y-jHRPcuE9kTT2Vy.png)

Image Credit: Think Like a Data Scientist, Brian Godsay

Some of the questions data science analysts should seek to answer include the specific goals of the exercise, the aim of gathering the data, and the factors to be estimated or predicted.

The data science process refers to the framework used to execute data science tasks. The process starts by asking an interesting question.

The second stage in the data science process is data collection. The key questions that data scientists ask at this stage include the data for sampling, what data is relevant, and what are the privacy issues to be considered.

The third stage in the process is data exploration. During this stage, data are plotted, and anomalies and patterns are identified.

The fourth stage involves data modelling, and data scientists perform activities such as building models, fitting models and validating models.

The last stage in the data science process entails communicating and visualizing the results. The questions, data scientists answer at this stage, include what lessons were learned, what is the meaning of the results, and what patterns do we draw from the data.

Data science is a complex process that requires extensive skills and tools to execute. One of the most commonly used data science process is CRISP-DM (Cross Industry Standard Process for Data Mining).

The key steps in CRISP-DM include business understanding, data understanding, data preparation, modeling, evaluation, and deployment.

From the steps, it is evident that the processes used in data science are the same regardless of the approach used. All the approaches to data mining start by asking a question or examining the insights to a specific phenomenon.

The KDD (Knowledge Discovery in Databases) process is another popular approach to data science. This framework uses specific data mining approaches to discover and extract patterns.

The key steps under this framework include selection, pre-processing, transformation, data mining, and interpretation. If the concept data mining is equated to modeling in the CRISP-DM, then the steps in the two approaches are similar.

## Tools for Data Science

The most common tools for data science include R, Python, and Matlab, which are very crucial for model development and visualization. R is commonly used in mathematical analysis and in displaying results.

R comes with numerous extension packages that enable data analysts to perform specialized operations that include text and speech analysis in addition to genomic analysis.

R is popular among analysts in industries such as health care, finance, pharmaceutical development and business.

However, python and python tools are the most commonly used, and data scientists who masters these languages have an edge.

### PYTHON VS R

Coming from a software engineering background, I prefer python.

The biggest advantage is:

Python is a general-purpose language with a flat learning curve, which increases the speed at which you can write a program.

While R is very popular in the academic world, and has a lot of packages to solve common problem, most of the common use-case for data science is in SaaS (Software As A Service). Python beats R hands-down.

### TOP PYTHON DATA SCIENCE PACKAGES:

If you’re looking to kickstart Data Science in Python, here are some key python packages solving today’s data science challenges:

- [Numpy](http://www.numpy.org/?ref=deletosh.com) — *powerful for its n-dimensional array, linear algebra transformations, fourier transforms, advanced random numbers generations*
- [statsmodels](http://www.statsmodels.org/stable/index.html?ref=deletosh.com) — *for statistical model. We can use this to explore data, estimate statistical models, and perform statistical tests. Lots of descriptive statistical analysis*
- [Scipy](https://www.scipy.org/?ref=deletosh.com) — *this is built on Numpy. Useful for high level science and engineering module (extends the Fourier transforms, linear algebra, optimization and sparse metrices)*
- [Matplotlib](https://matplotlib.org/?ref=deletosh.com) — *plotting all types of graphs from histograms, line plots, to heat plots.*
- [Pandas](https://pandas.pydata.org/?ref=deletosh.com) — *for structured data operations and manipulations. This mostly used for data mungling and prep.*
- [Scikit Learn](http://scikit-learn.org/stable/?ref=deletosh.com) — *primarily for machine learning built on Numpy, SciPy and matplotlib*
- [xlrd](https://pypi.python.org/pypi/xlrd?ref=deletosh.com) — *for reading and writing Excel files*
- [PyMC](https://pymc-devs.github.io/pymc/README.html?ref=deletosh.com#purpose) — *For Bayesian statistics, especially Markov chain Monte Carlo sims*
- [ray](https://github.com/ray-project/ray?ref=deletosh.com) — *the r-function made available on Python*
- [Seaborn](https://seaborn.pydata.org/?ref=deletosh.com) — *for statistical data visualization. For making informative and attractive graphics, based on Matplotlib*
- [Bokeh](https://bokeh.pydata.org/en/latest/?ref=deletosh.com) — *for interactive plots, dashboards, and data applications on the web.Looks and acts very much like D3.js*
- [Blaze](https://github.com/blaze/blaze?ref=deletosh.com) — *extends Numpy and Pends to distributed and streaming datasets. Can be used to access data from multiple different sources*
- [Scapy](http://www.secdev.org/projects/scapy/?ref=deletosh.com) — *for web crawling*
- [SymPy](http://www.sympy.org/en/index.html?ref=deletosh.com) — *for symbolic computations. From the basic algebra to quantum physics*
- [Requests](http://docs.python-requests.org/en/master/?ref=deletosh.com) — *for accessing the web. Very similar to urllib2, and much easier to code*

## Top Resource to Learn Data Science

### LEARNING PYTHON LANGUAGE

- [Learn Python Codecademy](https://www.codecademy.com/learn/python?ref=deletosh.com)
- [Python 3 in one picture](https://fossbytes.com/wp-content/uploads/2015/09/python-3-in-one-pic.png?ref=deletosh.com)
- [Dive Into Python](http://www.diveintopython.net/index.html?ref=deletosh.com) *This is expecially good for experienced programers*
- [Learn 90% of Python in 90 Minutes](https://www.slideshare.net/MattHarrison4/learn-90?ref=deletosh.com)

### DATA SCIENCE WITH PYTHON

- [Statistics and Data Science](https://github.com/svaksha/pythonidae/blob/master/Statistics.md?ref=deletosh.com)
- [Python for Data Science: Basic Concepts](https://github.com/gumption/Python%5Ffor%5FData%5FScience/blob/master/2%5FData%5FScience%5FBasic%5FConcepts.ipynb?ref=deletosh.com)
- [Web scraping in Python](https://github.com/ujjwalkarn/Web-Scraping?ref=deletosh.com)
- [Python For Data Science — A Cheat Sheet For Beginners](https://www.datacamp.com/community/tutorials/python-data-science-cheat-sheet-basics?ref=deletosh.com)

### LEARNING PANDAS

- [Intro to pandas data structures](http://www.gregreda.com/2013/10/26/intro-to-pandas-data-structures/?ref=deletosh.com)
- [10 minutes to Pandas](http://pandas.pydata.org/pandas-docs/stable/10min.html?ref=deletosh.com)
- [“Large data” work flows using pandas](http://stackoverflow.com/questions/14262433/large-data-work-flows-using-pandas?ref=deletosh.com)
- [Pandas Basics Cheat Sheet](https://www.datacamp.com/community/blog/python-pandas-cheat-sheet?ref=deletosh.com)

Machine Learning with Python

- [Data Normalization in Python](http://blog.yhat.com/posts/data-normalization-in-python.html?ref=deletosh.com)
- [Machine Learning Algorithms Cheatsheet](http://www.analyticsvidhya.com/blog/2015/09/full-cheatsheet-machine-learning-algorithms/?ref=deletosh.com)
- [Machine Learning with scikit learn](http://www.dataschool.io/machine-learning-with-scikit-learn/?ref=deletosh.com)
- [Python Machine Learning Book](https://github.com/rasbt/python-machine-learning-book?ref=deletosh.com)

Learning SciKit

- [A Gentle Introduction to Scikit-Learn: A Python Machine Learning Library](http://machinelearningmastery.com/a-gentle-introduction-to-scikit-learn-a-python-machine-learning-library/?ref=deletosh.com)
- [Machine Learning with scikit learn tutorial](http://amueller.github.io/sklearn%5Ftutorial/?ref=deletosh.com)
- [Code example to predict prices of Airbnb vacation rentals, using scikit-learn on Spark](https://github.com/mapr-demos/spark-sklearn-airbnb-predict?ref=deletosh.com)
- [Introduction to machine learning with scikit-learn](https://github.com/justmarkham/scikit-learn-videos?ref=deletosh.com), [Videos!](http://blog.kaggle.com/author/kevin-markham/?ref=deletosh.com)

Hope you got a look into the interesting and exciting world of data science.

Just ask away if you have any piece that needs clarification.
### 50 Ways I'm Trying to Get My LIFE Together
URL: https://deletosh.com/writing/50-principles/
Last updated: 2015-09-22T00:00:00.000Z
1. Live below my means, try hard to avoid all debt. If it’s really important if I can’t afford it now, I can save up for it, again, it can always wait.
2. Just as important is saving — especially for emergencies. It will happen, I have to realize, it.
3. Exercise. Everyday is ideal — we are meant to be active animals, sweat a bit everyday. I’m crazily addicted to [this app](https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=0CB4QFjAAahUKEwiQ6%5FqB8YvIAhWCXh4KHflDC%5FM&url=http%3A%2F%2Fwww.meetcarrot.com%2Ffit%2F&usg=AFQjCNEpRvxyjar6oJhCnCfx5ChROepMeA).
4. Be capable of self-defense. One day, there will be a need for it, and at that point, it might be too late.
5. Pursue goals that don’t require money. There is always joy in getting expertise in something that I enjoy — I will pursue this a lot more.
6. Travel, travel more and more before spending money on houses or cars. I should buy time, and memories and use it, before “settling down”.
7. Give back. Always.
8. Do the right thing every time. In fact, this should become a habit.
9. Say “I love you” wholeheartedly. And without self-consciousness.
10. Read more. Shooting for a book a week. I dutifully do this [here](http://www.goodreads.com/challenges/3082-2015-reading-challenge?ref=deletosh.com)
11. Take Responsibility for my actions.
12. If I want it, I take it, and pay the price. I’ve found there is really no free lunch. Nope. No free lunch ever.
13. Be willing to let go of beliefs. If what I’ve done in the last 5 years isn’t working, I should be willing to change it.
14. Be moderate. And sometimes, go overboard — it’s OK.
15. Stop making excuses. It’s never anyone’s fault, I have the ability to now control my self, nothing will work until I start owning up to things.
16. Follow through on things. Start something, if it’s not working, stop it, or move it to complete,; I shouldn’t leave things hanging everywhere.
17. Keep a master list of long-range goals.
18. Accept defeat with grace. Many of it will happen.
19. Know how to cheat. It’s a fact of life, many will want to take advantage of me, I should understand how to deal with it. [This book was of great help](http://www.amazon.com/Get-Rich-Cheating-Crooked-Street/dp/B002YX0C9K?ref=deletosh.com)
20. If it’s critical do it myself, it it’s not delegate. This difference is important.
21. Don’t lie. If telling the truth in a situation is difficult, speaking my way around it, never lying.
22. Don’t borrow. Pay as I go; borrowing keeps me indebted to the person I owe.
23. Spending time with someone is more important than spending money. It’s important.
24. Tragedy happens. I have to learn what I can from the situation and move on.
25. Be prepared. Always, at least as much as I can be.
26. Get lost once in a while. Not just in my head, by physically get lost, and savor the moment. Stop playing it too safe.
27. Carry a folding knife. It’s a tool of choice for our species for years. [I always carry this](http://www.amazon.com/gp/product/B003IX11YA?psc=1&redirect=true&ref%5F=oh%5Faui%5Fdetailpage%5Fo05%5Fs00&ref=deletosh.com).
28. Buy quality and take care of it. Forget junk! It might start our been cheap, but it gets expensive.
29. Set boundaries and respect them. Ignore people who don’t
30. Don’t try to change anyone. It’s important to learn the difference between help and co-dependent enabling.
31. Stop arguing. It gets exhausting.
32. Lead by example, not big, and long talk.
33. I will be an idiot occasionally. I should embrace is a an opportunity to tell good stories, learn from it, and forgive myself.
34. Don’t be selfish.
35. Say “please” and “thank you”. Simple courtesy that’s easy to forget, I should do it a lot more.
36. Turn the TV off and go read. No excuses
37. Listen more than I talk.
38. Learn empathy.
39. Go the extra mile. Even when no one does it for me.
40. What doesn’t kill me, make me stronger.
41. Not everyone likes me. And that’s OK, I don’t have to try to please everyone.
42. Right now is good time to stop the bullshit. Get real, it might hurt, but I’d be real.
43. Someone is waiting for me to ask. Ask today.
44. I’m occasionally obvious to the obvious. I should keep my eyes wide open.
45. Don’t buy stuff on sale. If I need is, buy, it. I must respect value not price.
46. Love will always have baggage attached. Get over it, and enjoy the moment.
47. The easy way is often the right way. I should always keep things as simple as possible.
48. Learn my craft — never look for shortcuts. I have to pay my dues, I should find my path and walk it.
49. What people think of me is irrelevant BUT the mark I leave on the world matters. I must play my part to make the world of those around me a better place. Real courage is fear in action. I cannot afford to underplay my hand.
50. No one gets out of this world alive. I have to live my life with full gusto.
### Getting Up and Going in Life
URL: https://deletosh.com/writing/getting-up/
Last updated: 2014-11-17T00:00:00.000Z
---

One day you will wake up and it might seem like you’re up against a brick wall, it might seem all bleak.

You’re not alone. Here’s some relieve:

- Every night, think of two things you’re grateful for, write them down. Even better, if they involve people, thank them; over the phone, via email, or in person.
- Try meditation. It relaxes your waring mind. If you have trouble concentration, trying saying a prayer or a chant for about 3–5 mins.
- Exercise, as much as you can. Nothing heavy, go outside, take a short walk, it’s magic.
- Wake up early, if you can. If you can’t, always go to bed early. If you have trouble sleeping — exercise.
- Reduce your consumption of media. Social media and TV especially — they are time sinks and depressing.
- Read a Book. Any book you will enjoy, don’t feel you have to finish a book, just engage in the act.
- Set small goals, and accomplish them. It could be even as simple as, get out of bed at 5:30am.
- Engage in random acts of kindness, even if you have no reason to — just do it.
- Smile. Even you can’t, fake it.

---
### How to Start Living your Life and Stop Caring about other "Crap"
URL: https://deletosh.com/writing/start-living/
Last updated: 2014-08-31T00:00:00.000Z
My friend confessed to me something we all face everyday: she’s too worried about what people will say, or how people will perceive her if she does something she really wants to do.

She’s not living her life.

I was once there, and sometime still face the perils. This piece changed how I approached “…but they’d say about me”.

This piece is almost verbatim, I only cleaned it slightly to me it “PG”. The original article is [here](http://inoveryourhead.net/the-complete-guide-to-not-giving-a-fuck/?ref=deletosh.com), by [Julien Smith](http://inoveryourhead.net/about-julien/?ref=deletosh.com)

Ok, I have a confession to make.

I have spent almost my whole life– caring far too much about offending people, worrying if I’m cool enough for them, or asking myself if they are judging me.

I can’t take it anymore. It’s stupid, and it’s not good for my well being. It has made me a punching bag– a flighty, nervous wuss. But worse than that, it has made me someone who doesn’t take a stand for anything. It has made me someone who stood in the middle, far too often, and not where I cared to stand, for fear of alienating others. No more. Not today.

Today, ladies and gentlemen, is different.

> *We’re going to talk about the cure. We’re going to talk about what’s necessary. We’re going to talk about the truth.*

Do you wonder if someone is talking shit about you? Whether your friends will approve? Have you become conflict-avoidant? Spineless?

Well, it’s time you started caring less.

### FACT NUMBER 1: People are judging you right now.

Yes, it’s really happening right at this moment. Some people don’t like you, and guess what? There’s nothing you can do about it. No amount of coercion, toadying, or pandering to their interests will help. In fact, the opposite is often true; the more you stand for something, the more they respect you, whether it’s grudgingly or not.

What people truly respect is when you draw the line and say “you will go no further.” They may not like this behavior, but so what? These are people don’t like you anyway, why should you attempt to please people who don’t care for you in the first place?

Regular people are fine– you don’t actually hear it when they’re talking behind your back. But on the web, you do see it, which changes the dynamic drastically. They have an impact because they know you have your vanity searches, etc. But the real problem with Internet haters is that they confirm your paranoid delusion that everyone out there secretly hates you.

Thankfully, that’s not actually true. So the first noble truth is that most people don’t even care that you’re alive. Embrace this, my friends, for it is true freedom. The world is vast and you are small, and therefore you may do as you wish and cast your thoughts of those who dislike it to the side.

### FACT NUMBER 2: You don’t need everyone to like you.

This stuff is crazy, I know, but it’s cool, you’ll get used to it. Here’s the next thing: not only do most people not know that you exist, and some are judging you, but it totally does not matter even if they are.

How liberating this is may not even hit you yet, but it will. Check this out: when people don’t like you, nothing actually happens. The world does not end. You don’t feel them breathing down your neck. In fact, the more you ignore them and just go about your business, the better off you are.

> *You know when they say “the best revenge is a life well lived”?*

Well, this is true, but it isn’t the whole truth. A life well lived is great, yes, but it cannot happen while you are sweating about who your detractors are and what they think. What you have to do, what you have no choice but to do, is accept it and move on.

So, caring less is actually a necessary precedent to create a good life for yourself. It can’t happen without it. That’s why you have to begin today.

### FACT NUMBER 3: It’s your people that matter.

Ok, so you’ve adjusted to the fact that most people in the world are barely aware of your existence, and you’re also conscious of the fact that those who don’t like you are in the obscenely small minority and don’t actually matter. Awesome. Next you need to realize that the people who do care about you, and no one else, are those you need to focus on.

Relationships are weird. Once we’re in one (with family, a spouse, whatever), we promptly begin to take the other person for granted and move on to impressing strangers instead– say, our boss. Then, once we’ve impressed our boss, we start taking him for granted too, and so on, in an endless cycle of apathy. It’s like we always prefer to impress and charm the new than to work on what we already have.

But these people– your champions– they understand your quest or your cause. They make you feel good when you’re around them, make you laugh or make you feel like you can just be yourself. They make you feel relaxed or at ease. You’ve shared things with them. They’re important.

Focus on them instead.

### FACT NUMBER 4: Those who don’t care change the world. The rest do not.

If you dismiss the things that do not matter; if you remove those things from your mind and focus on what must be done; if you understand that your time is limited and decide to work now; only then will you be able to get to the finish line. Otherwise, you will be dissuaded into living a life you aren’t interested in.

Side note: You need to handle failure and obscurity better. You may be in a tough place right now where you feel lonely or like a loser. No worries, we’ve all been there. But it’s time for you to realize how common these things are, and that they’re experienced by even the most successful and happiest people in the world. Those people get past them, and you will too.

The eye is watching

You want to know something? This actually has nothing to do with anyone else. It has everything to do with you.

Everyone has an internetal eye. It always watching. It has been slowly constructed by society at large and by your friends and family, and it checks you for unacceptable behaviour. If you have had it around for long enough, you actually start to believe that the eye is you, and that you’re “being reasonable” or some other rationalization.

But the eye isn’t you at all. It is a prison, and you have justified its existence by obeying it. It’s strong because you let it be strong.

But the secret, the part that’s amazing, is that it can’t do anything to stop you, even if it wanted to. It’s an eye. It can only watch. The rest of you is free to act as you wish.

### How to get back your self-respect in 5 easy steps

### STEP 1\. Do things that you consider embarrassing.

My girlfriend and I have been breaking in Vibram Fivefingers in preparation for the massive walk we are doing. Have you ever seen these shoes? They’re amazing for you knees and give you no blisters, but they are the ugliest thing imaginable. Yesterday, I wore them with a sweet bowtie I put on for Easter. I looked like a crazy person.

As I said at the beginning of this post, I am deeply aware and can become quite upset by people’s judgment– I think a lot of people are, but don’t admit it. But as I walked by people in my techno-clown outfit, not a single person looked at me. Nobody cared, and it slowly dawned on me that even if people did look at me weird, they just walked by. Later, they would forget about me entirely.

You must try this. Find your internal filters and break them, one at a time. Notice how society, like an ocean, smoothes over the waves you make, until what you do gets eliminated, or becomes the status quo. Work with this.

### STEP 2\. Accept, or deal with, awkwardness.

It’s widely known that interviewers get their best material by being quiet and allowing silence to force words out of a politician or celebrity.

You may be uncomfortable with silence. I know I still am. But I have been working on it and have to say that it is a much more serene state to be in than trying to cover it up with random babbling just to fill up the air. This is one type of awkwardness, a kind that you should feel comfortable about and learn to live with.

Another kind of social awkwardness is this in-between space where you might have done something wrong or been wronged, but don’t say anything. I’ve been given a few harsh lessons in my time and come away realizing that the freedom that comes from talking about an uncomfortable truth is better than the comfort of avoiding that talk altogether.

Someone told me recently that the Clintons’ method for earning respect in politics is this: if someone pushes you, push back twice as hard. This is much better than awkwardness. It’s clear, it’s not passive aggressive, and you know where you stand. Start doing this immediately.

### STEP 3\. Refuse boundaries.

### STEP 4\. Tell the truth.

You don’t need to be a jerk, but the world does not need another conflict-avoidant, evasive person. No one wants another individual who steps in line with everyone else. The status quo is doing fine without you, so it’s up to you to call bullshit if you see it.

Don’t mind-read either. Telling the truth means seeing the truth, not adding your own layer of sugar coating or suspected emotionon top of it.

### STEP 5\. Begin your new life.

This step can’t happen without the others, but once you’ve gotten here, you can safely begin to explore a whole new world– one where anything you do is fine as long as it isn’t seriously hurting anyone else. Wanna explore old abandoned buildings? No problem, as long as you’re ready to live with the consequences. Feel like hanging from hooks or get whipped by a dominatrix? Go ahead, but be safe about it.

Once you begin on this path, you start to discover that practically everyone is capable of understanding the weird things that you do. In fact, it makes you interesting and worth paying attention to, further feeding into your plans of world domination, should you have any.

But none of this fun can happen without you recognizing, and walking past, the eye. Doing this is a powerful act of control which builds momentum and makes you strong.

Take back your self respect. Do it today– try it right now. Wear something ugly. Do something stupid. Tell someone the truth.

It doesn’t matter.

What do you think about it? Leave me a comment, let’s discuss.
### Deconstructing Learning
URL: https://deletosh.com/writing/deconstructing-learning/
Last updated: 2010-06-05T00:00:00.000Z
I started blogging second semester of my freshman year in college; some semesters later, graduation time calls and the question is, do I have anything to say about college life/experience/insight.

Because I’ve forgotten most of what I learned freshman year (get the point?) and some semester after that, I think I’ve even forgotten most of what I was taught last and this past semester–after all, I got good grades.

Education is one of the options. Western education forces \[most of\] us into a box and a pattern of learning that our brains might not be tuned for. Schools assume we learn the same way, would know the same thing, should know the same thing and understand and ultimately apply the same way (with slight exceptions)…Here are some of my miscellaneous ideas on college (university) life. (Listed in no particular order of importance)

*If you had the chance, what would you change about your college life?*  
During orientation, the leader made an important remark: “don’t just pass through the school, let the school pass through you.” The only way I interpreted this then was: read and get as much good grades as you can, don’t leave school without those top-notch grades because without them, you are a success.I would definitely change my perception of that.

I would definitely be more involved in college extra-curricular activities, and some more. There is a trade off. I didn’t start getting involved in campus activities till my senior yet (which I painfully learned, was too late)–joining those clubs, meeting people, involving in community service, travel abroad (if affordable) and all those non-grade related activities.

i found that obsession with grades and grades alone has one ‘just’ passing through college; the experience that is gotten through the people relation is a skill that no college course would match. If I had the chance, I would learn more of these, point? Be actively involved in campus activities.

*You said “trade off”, what is that?*  
You exist as one entity and usually mer mortals like me can only do one thing at a time; getting involved in campus activity might take away time that could be used for studying or better put, studying could suffer. it is up to anyone to decide how to balance (all nighters?) or settle for a lesser grade. In my case, I tried understanding priorities and made trade off respectively, it is case dependent. Sometimes settling for a lesser grade does it, sometimes getting hyped on energy drinks (drugs?) does it, sometimes just not getting involved at all those it, I don’t recommend not getting involved at all, I can’t stress it enough.

*Wait…did I hear you mention drugs …?*  
Abusing drugs is bad, very bad and I wouldn’t mention it. Yes I did. I’m referring to some drugs that help you ‘cheat’ sleep–caffeine. To be honest, I wasn’t referring to caffeine. There gets to the point where caffeine just doesn’t do it and there comes in a drug my friend told me about (usually prescribed for people with ADHD). She told me i not only successfully helps you skip sleep, it helps you focus. I really had to enquire being curious how this girl could start and finish pages of paper overnight. I never used it and if you’re curious, google ‘provigil’. Perhaps you can convince your doctor to prescribe it to you (I’ve heard making up stories does it) or you can ‘hawk’ it, all at your expense.

*Do you think you’ve amassed knowledge attending college?*  
Yes, academically and socially. The question might follow, “can these knowledge be acquired alternatively?” A big yes! Especially the academic part, and maybe faster. Considering that we are thought collectively, everyone learning at different paces, there will generally be a fallback or rush and this again makes the point for the oddness of school assuming we all learn equally.

*What was you favorite thing about college?*  
Freebies! From free fun to free food, free events to free people, take advantage of them all. When one steps out of the college life, you are expected to pay for stuff or the pursuit of freebies might just be too stressful. Plus, people are very understanding when you say: “I’m a student.” Or when there is the readily available excuse: “…because of school”. Now, post-college, everyone expects you to accept responsibilities. Free food is just my favorite

*What about your academic favorite?*  
The best class i took in college was in my sophomore year: Java 1 & 2 and Software Engineering taught by Joseph Kazpryzk (My favorite professor) and Public Finance. And honestly, I’ve forgotten most of the several courses I took. Think about that…I have forgotten most of the course i took in college, so what’s the point?

*So, what do you think is the point of college?*  
Not necessarily about the grades; I can’t emphasize enough but about the progressive knowledge. If someone mentions ‘Capitalist Development Theories’ I wouldn’t be blank or in the remote chance I would have to use that accumulated knowledge in real world, I have something to build on.

Most classes I took applied in some form to an application even Calculus, yes, calculus. They all shape you thinking, or to put different expand the brain’s possibilities and I should add, take tough classes, classes that challenge your norm (perhaps ignoring grades)

*How can one be successful in college?*  
If your definition of success is high grades, the only way is study smart. For this, keep in mind that the means doesn’t matter, only the end those; use every justifiable way to get the grades you want. If success means a holistic learning (not just academic), then, network as much as possible. How? Join as much campus activity as possible, I’ve probably said this already but can’t say it well enough. There is no shortcut to success, study, work hard.

While professors will try to reach you what they know, one has to do much learning him/her-self. Read, and read.

*What’s Next?*  
That’s the usual question when one graduates and my answer: like the Persuasions sang: “Anyway the wind blows, it’s fine with me.” Getting a degree is just a small stepping stone in my learning and development. Learning is continuous.