/forbotsake-marketing-start

---
name: forbotsake-marketing-start
description: >
  The starting point for marketing your product. Reads your codebase to
  understand

  what you built, asks 5 hard questions about positioning, audience, and
  channels,

  then produces strategy.md with your marketing strategy and first concrete
  move.

  Use when: "how should I market this", "go-to-market", "GTM", "positioning",

  "I don't know how to sell this", "help me market", "marketing strategy".

  Proactively invoke when the user asks about marketing, growth, or getting
  users

  and no strategy.md exists yet.
---

# /forbotsake-marketing-start

The entry point. From zero marketing knowledge to a strategy you can execute.

## Preamble

```bash
FORBOTSAKE_HOME="${FORBOTSAKE_HOME:-$HOME/.forbotsake}"
mkdir -p "$FORBOTSAKE_HOME"

# Discover forbotsake install directory
_FBS_ROOT=""
for _FBS_CANDIDATE in "$HOME/.codex/skills/forbotsake" "$HOME/.agents/skills/forbotsake"; do
  [ -d "$_FBS_CANDIDATE" ] && _FBS_ROOT="$_FBS_CANDIDATE" && break
done
if [ -z "$_FBS_ROOT" ]; then
  echo "WARNING: forbotsake not found. Install: bash <(curl -fsSL https://raw.githubusercontent.com/forbotsake/forbotsake/main/bin/install.sh)"
fi

# Check for updates
_UPD=""
[ -n "$_FBS_ROOT" ] && [ -x "$_FBS_ROOT/bin/forbotsake-update-check" ] && _UPD=$("$_FBS_ROOT/bin/forbotsake-update-check" 2>/dev/null || true)
[ -n "$_UPD" ] && echo "$_UPD" || true
_BRANCH=$(git branch --show-current 2>/dev/null || echo "unknown")
echo "BRANCH: $_BRANCH"
```

```bash

# Check for existing strategy.md
if [ -f strategy.md ]; then
  echo "EXISTING_STRATEGY: yes"
  head -5 strategy.md
else
  echo "EXISTING_STRATEGY: no"
fi

# Orchestrated mode (invoked by forbotsake-go, propagated via file flag)
_ORCH_FILE="${FORBOTSAKE_HOME:-$HOME/.forbotsake}/orchestrated-$(basename "$(git rev-parse --show-toplevel 2>/dev/null || pwd)")"
FORBOTSAKE_ORCHESTRATED=$(cat "$_ORCH_FILE" 2>/dev/null || echo 0)
echo "ORCHESTRATED: $FORBOTSAKE_ORCHESTRATED"

# Check for session resume file
_SESSION_FILE="$FORBOTSAKE_HOME/session-$(basename "$(git rev-parse --show-toplevel 2>/dev/null || pwd)").json"
if [ -f "$_SESSION_FILE" ]; then
  echo "RESUME_AVAILABLE: yes"
  echo "SESSION_FILE: $_SESSION_FILE"
else
  echo "RESUME_AVAILABLE: no"
fi
```

If output shows `UPGRADE_AVAILABLE <old> <new>`: read the forbotsake-upgrade SKILL.md
at `$_FBS_ROOT/forbotsake-upgrade/SKILL.md` (where `_FBS_ROOT` is the variable already
resolved in the preamble bash above) and follow the "Inline upgrade flow" section **Step 1
only**. If Step 1 results in "Yes" or "Always" (proceed with upgrade), continue through
Steps 2-7 of the inline flow. If Step 1 results in "Not now" or "Never" (declined),
skip Steps 2-7 entirely and continue with this skill immediately.

If output shows `JUST_UPGRADED <old> <new>`: tell user
"Running forbotsake v{new} (just updated from v{old})!" and continue.

**Orchestrated mode (`ORCHESTRATED` is `1`):**
- If `EXISTING_STRATEGY` is `yes`: Skip this skill entirely. Say: "Using existing strategy.md." Then stop — do NOT proceed to Phase 1 or any questions. The orchestrator handles what's next.
- If `EXISTING_STRATEGY` is `no`: Proceed normally through Phases 1-4 (the 5 questions require genuine human input). But skip Phase 5 (Next Steps) — the orchestrator handles what's next.
- Ignore resume files in orchestrated mode.

**Interactive mode (`ORCHESTRATED` is `0`):**

If `EXISTING_STRATEGY` is `yes`, check frontmatter for `generated_by: forbotsake`.
- If forbotsake-generated: "Found existing strategy.md. Want to update it or start fresh?"
- If not forbotsake-generated: "Found strategy.md not generated by forbotsake. Use it as input, or create alongside as forbotsake-strategy.md?"

Ask the user directly in conversation. Do NOT overwrite without asking.

If `RESUME_AVAILABLE` is `yes`: "Found a previous session in progress. Resume where you left off?"
Ask the user directly in conversation with options: A) Resume, B) Start fresh.

## Phase 1: Show Intelligence First

Before asking ANY questions, demonstrate you understand the product.

1. Read `README.md` (if exists)
2. Read `CLAUDE.md` (if exists)
3. Run `git log --oneline -20` to see recent activity
4. Read `package.json`, `Cargo.toml`, `go.mod`, `pyproject.toml`, or equivalent to identify the tech stack
5. Grep for key terms: "user", "customer", "pricing", "api", "docs"

Then present a 3-4 sentence summary:

> "Based on your repo, you're building [product description]. Your tech stack is [stack].
> Recent activity suggests [what you've been working on]. Your likely audience is [guess].
> Let me validate that with 6 questions."

This flips the dynamic from "fill out this form" to "this tool already gets me."

## Phase 2: Five Forced Questions

Ask these ONE AT A TIME via direct conversation with the user. After each answer, save it to the session file.

**Session save after each question:**
```bash
# Save Q&A to session file for crash resume
echo '{"q": QUESTION_NUMBER, "question": "QUESTION_TEXT", "answer": "USER_ANSWER"}' >> "$_SESSION_FILE"
```

### Q1: Problem/Solution Clarity

> "You said you're building [product from Phase 1]. In one sentence:
> what specific problem does it solve, and for whom?
>
> Example: 'For devtool founders who just shipped, it eliminates the guesswork
> of marketing by asking the right questions before you write a single post.'"

Push for specificity. "Developers" is not specific. "Backend engineers at Series A startups
who need to document their API" is specific.

### Q2: ICP via Elimination

> "Name the ONE person who would be most upset if [product] disappeared tomorrow.
> Not a category. A person.
>
> What's their title? What gets them promoted? What keeps them up at night?
> What are they using RIGHT NOW to solve this problem, even badly?"

If the answer is a category ("SMBs", "marketers"), push back: "That's a filter, not a person.
Can you name someone specific, even if fictional?"

### Q3: Channel-Market Fit

> "Where does your person from Q2 already spend their attention?
> Score these channels 1-10 for YOUR product (10 = perfect fit):
>
> - X/Twitter
> - LinkedIn
> - Reddit
> - Hacker News / Show HN
> - SEO / Blog
> - Email / Newsletter
> - YouTube / Video
> - Product Hunt
>
> You don't need to score all of them. Just the ones where your ICP actually hangs out."

### Q4: Messaging

> "How would you explain [product] to [ICP from Q2] in a way that makes them
> stop scrolling?
>
> Not your landing page copy. Not your pitch deck. The thing you'd say at a
> meetup that makes them go 'wait, tell me more.'
>
> One sentence. Maybe two."

If the answer sounds like a press release, push back: "That sounds like marketing copy.
What would you actually SAY to [ICP name]?"

### Q5: First Experiment

> "If you could only do ONE marketing activity for the next 2 weeks, what would it be?
>
> Don't overthink it. Given what you said about channels (Q3) and messaging (Q4),
> what's the single action with the highest chance of reaching [ICP from Q2]?"

### Q6: Your Position (for founder-profile.md)

> "Last question — this one's about YOU, not your product.
>
> What communities or organizations are you part of? (YC, indie hackers, specific
> Slack/Discord groups, open source projects, professional orgs?)
>
> Who do you know in your space? Not celebrities — people you could actually
> message. Former colleagues, fellow founders, community leaders, investors.
>
> What's your unfair advantage for reaching your ICP? Maybe you're already
> active on the channel they use. Maybe you built something they depend on.
> Maybe you're in the same community."

Push for specifics. "I know some people" is not useful. "I'm a YC founder, I know
3 other founders building devtools, and I'm active in r/ClaudeAI" is useful.

**Session save after answer:**
```bash
echo '{"q": 6, "question": "your_position", "answer": "USER_ANSWER"}' >> "$_SESSION_FILE"
```

## Phase 3: Write strategy.md AND founder-profile.md

After all 6 questions are answered, write both files.

### Write founder-profile.md

Write to `~/.forbotsake/founder-profile.md`:

```bash
FORBOTSAKE_HOME="${FORBOTSAKE_HOME:-$HOME/.forbotsake}"
mkdir -p "$FORBOTSAKE_HOME"
```

```markdown
---
schema_version: 1
generated_by: forbotsake
generated_at: {ISO timestamp}
---
# Founder Profile

## Identity
- **Name:** {inferred from git config or conversation}
- **Role:** {from conversation context}
- **Location:** {if mentioned, else "(Not captured)"}

## Affiliations & Communities
{from Q6 — list each affiliation with relationship type}

## Key Relationships
{from Q6 — list each person with nature of relationship}

## Unfair Advantages
{from Q6 — each advantage with why it matters for marketing}

## Communication Style
- **Preferred platforms:** {from Q3 — where they scored themselves highest}
- **Voice/tone:** {from Q4 — how they naturally talk about their product}

## Open Paths
{Warm introduction paths inferred from Q6 affiliations + Q2 ICP. Which connections
could introduce you to your ICP or amplify your message?}
```

Tell the user: "Founder profile saved to `~/.forbotsake/founder-profile.md`.
This is used by `/forbotsake-sharpen` to find warm paths and tailor outreach."

### Write strategy.md

Write `strategy.md` to the project root.

**Read knowledge frameworks first:**
```bash
_SKILL_DIR=$(dirname "$(find $HOME/.codex/skills -path "*/forbotsake-marketing-start/SKILL.md" -type f 2>/dev/null | head -1)")
echo "SKILL_DIR: $_SKILL_DIR"
```

Read `$_SKILL_DIR/../knowledge/frameworks/positioning-canvas.md` and
`$_SKILL_DIR/../knowledge/frameworks/channel-selection.md` for methodology reference.

Write strategy.md with this schema:

```markdown
---
schema_version: 1
generated_by: forbotsake
generated_at: {ISO timestamp}
---
# Marketing Strategy: {product name}

Generated by /forbotsake-marketing-start on {date}
Status: DRAFT

## Positioning Statement

For {ICP from Q2}, {product} is the {category} that {key benefit from Q4}
unlike {current solution from Q2}.

## Ideal Customer Profile

- **Person:** {from Q2}
- **Title/Role:** {from Q2}
- **Pain point:** {from Q1}
- **Current solution:** {what they use now, from Q2}
- **Trigger event:** {what makes them search for a solution NOW}
- **Where they hang out:** {top channels from Q3}

## Channel Strategy

| Channel | Score | Rationale | Content Format | Cadence |
|---------|-------|-----------|----------------|---------|
{from Q3, ranked by score, top channels only}

## Messaging Pillars

1. **{Pillar 1}:** {from Q4, expanded with proof points}
2. **{Pillar 2}:** {derived from Q1 + Q2}
3. **{Pillar 3}:** {derived from product capabilities}

## First 2-Week Experiment

Based on Q5:
- **Channel:** {top channel from Q3}
- **Action:** {from Q5}
- **Content:** {specific pieces to create}
- **Success metric:** {what to measure}
- **Decision criteria:** {what number means "keep going" vs "try channel #2"}

## First Move

**Do this TODAY:**

{A single, specific, concrete action the founder can take in the next 60 minutes.
Not "write a blog post." Something like: "Write a 5-tweet thread about [specific topic]
targeting [specific persona]. Post it at 10am PT. Include [specific hook]. End with
[specific CTA]." The more specific, the better.}

## Open Questions

{Anything unresolved from the conversation. Things to validate with real users.}
```

## Phase 3.5: Brand Visual Identity

After writing strategy.md and founder-profile.md, create the brand visual identity.

> "Now let's define your visual identity. This lets forbotsake generate images
> and text-cards that match your brand when you create content."

**Read the brand identity framework:**
```bash
_SKILL_DIR=$(dirname "$(find $HOME/.codex/skills -path "*/forbotsake-marketing-start/SKILL.md" -type f 2>/dev/null | head -1)")
echo "SKILL_DIR: $_SKILL_DIR"
```

Read `$_SKILL_DIR/../knowledge/frameworks/brand-identity.md` for the full schema.

**Auto-extraction path (preferred):**

Check if the user mentioned a website URL in their strategy.md or conversation:
- If URL available: "I can extract your brand identity from your website. Let me screenshot it and pull colors, typography, and visual mood."
  1. Use Chrome automation to screenshot the URL
  2. Pass the screenshot to Claude with: "Extract the dominant color palette (hex codes for primary, accent, background, text), typography feel (serif/sans-serif, modern/classic), and visual mood (3 adjectives) from this webpage. Output as YAML matching the brand.md schema."
  3. Present the extracted brand.md to the user for approval before saving
- If no URL: proceed to manual path

**Manual path:**

Ask via direct conversation with the user:

> "Let's define your visual identity for generated images and cards.
>
> 1. What's your primary brand color? (hex code like #1a1a2e, or describe: 'dark blue')
> 2. What's your accent color? (the pop of color for CTAs and highlights)
> 3. How would you describe your visual style? (e.g., 'minimal and technical', 'bold and playful', 'clean and professional')
> 4. What type of images fit your brand? (e.g., 'flat illustrations', 'photography', 'abstract geometric', 'diagrams')
> 5. Anything to avoid? (e.g., 'no stock photos', 'no clipart', 'nothing corporate')"

Write `brand.md` to the project root:

```markdown
---
schema_version: 1
generated_by: forbotsake
generated_at: {ISO timestamp}
---
name: "{product name from strategy.md}"
colors:
  primary: "{from Q1}"
  accent: "{from Q2}"
  background: "#f5f5f5"
  text: "#1a1a2e"
typography:
  mood: "{from Q3, e.g., 'modern sans-serif, clean, technical'}"
  heading_style: "bold, uppercase for short titles"
visual_style:
  mood: [{from Q3, as array of adjectives}]
  image_type: "{from Q4}"
  avoid: [{from Q5, as array}]
logo:
  path: ""
  placement: "bottom-right"
prompt_prefix: "{auto-generated from above: combine image_type + mood + color references}"
```

**Validation:** Check that colors.primary and colors.accent are valid hex codes (regex: `^#[0-9a-fA-F]{6}$`). If user gave a color name, convert to hex.

Tell the user: "Brand identity saved to `brand.md`. This is used by `/forbotsake-create` to generate on-brand images and text-cards."

**Orchestrated mode (`ORCHESTRATED` is `1`):** If brand.md already exists, skip this phase. If it doesn't exist, use the auto-extraction path if a URL is available, otherwise skip with a note: "No brand.md found. Visual generation will use default styles. Run `/forbotsake-marketing-start` interactively to set up brand identity."

## Phase 4: Self-Test

After writing strategy.md, read it back and check:

1. Does the positioning statement pass the "would your ICP forward this?" test?
2. Is the First Move specific enough to execute in 60 minutes?
3. Are the channel scores justified with real reasoning?

If any check fails, tell the user what's weak and offer to revise.

## Phase 4.5: Strategy Reviewer (Adversarial Gate)

**Skip this phase if `FORBOTSAKE_FAST` env var is `1`.** Print: "FORBOTSAKE_FAST=1: skipping adversarial strategy review."

After the self-test passes, an independent reviewer evaluates the strategy with fresh
context. This catches vague positioning, generic ICPs, and unjustified channel scores
that the self-test (same model reviewing its own work) might miss.

### Step 1: Dispatch the reviewer

Run the review inline to spawn an independent reviewer subagent. The subagent sees ONLY
strategy.md, not the conversation that produced it.

**Subagent prompt:**

> You are a strategy reviewer for a marketing strategy document. Your job is to find
> weaknesses that would cause downstream content to fail.
>
> Read the file at {strategy.md path}.
>
> Review on 5 dimensions:
> 1. POSITIONING SPECIFICITY: Would the ICP forward the positioning statement to a colleague? Or is it vague enough to describe any product in this space?
> 2. ICP CONCRETENESS: Is this a real person with a name, role, and specific pain? Or a marketing category like "SMBs in healthcare"?
> 3. CHANNEL JUSTIFICATION: Are channel scores backed by reasoning (why THIS channel for THIS audience), or just vibes?
> 4. FIRST MOVE EXECUTABILITY: Can someone start this action in 60 minutes? Or is it vague like "write a blog post"?
> 5. COMPETITIVE AWARENESS: Does the positioning acknowledge what alternatives exist and why this is different? Or does it pretend the market is empty?
>
> For dimensions where the strategy.md lacks the relevant field, skip that dimension
> and note "field not present" instead of failing.
>
> Respond with ONLY valid JSON, no markdown fences:
> {"result": "PASS" | "NEEDS_REVISION", "findings": [{"dimension": "...", "verdict": "PASS" | "FAIL", "issue": "what's wrong", "fix": "specific suggestion"}], "summary": "one-line assessment"}

### Step 2: Parse and act

If JSON parsing fails: treat as PASS with visible warning:

> "**Strategy Reviewer: UNAVAILABLE** (returned unparseable output). Proceeding with self-test results only. The strategy was NOT independently reviewed."

Log to metrics: `{"gate":"strategy","result":"PARSE_FAIL"}`. Continue to Phase 5.

**PASS:** Print "Strategy Reviewer: PASS. Strategy is specific enough to produce good content." Continue to Phase 5.

**NEEDS_REVISION:** Present findings:

> "**Strategy Reviewer: NEEDS_REVISION**
>
> An independent reviewer found weaknesses that would affect downstream content:
> {for each finding with verdict FAIL:}
> - **{dimension}:** {issue}. Fix: {fix}
>
> This is iteration {N} of 2."

- **Interactive mode:** Ask the user directly in conversation:
  A) Apply fixes and re-review
  B) I'll revise manually
  C) Override, strategy is fine as-is
- **Orchestrated mode:** Auto-apply one round of fixes, re-dispatch. After 2 iterations, proceed with concerns logged in strategy.md frontmatter.

If override: add `review_status: override` to strategy.md frontmatter.

### Step 3: Log metrics

```bash
FORBOTSAKE_HOME="${FORBOTSAKE_HOME:-$HOME/.forbotsake}"
mkdir -p "$FORBOTSAKE_HOME"
echo '{"gate":"strategy","ts":"'"$(date -u +%Y-%m-%dT%H:%M:%SZ)"'","result":"RESULT","iterations":N,"override":BOOL}' >> "$FORBOTSAKE_HOME/review-metrics.jsonl" 2>/dev/null || true
```

## Phase 5: Next Steps

**Orchestrated mode (`ORCHESTRATED` is `1`):** Skip this phase entirely. Confirm: "Strategy written to strategy.md." Then stop.

**Interactive mode (`ORCHESTRATED` is `0`):** Tell the user:

> "Your strategy.md is ready. Here's the pipeline:
>
> **Next:** `/forbotsake-cmo-check` to challenge this strategy and force alternatives.
> **Then:** `/forbotsake-content-plan` to build your content calendar.
> **Then:** `/forbotsake-create` to write your first piece of content.
>
> Or just go execute the First Move right now. Sometimes the best strategy
> is the one you actually do."

## Cleanup

Remove the session file on successful completion:
```bash
rm -f "$_SESSION_FILE" 2>/dev/null
```