Peec Setup

AI Visibility Setup

Role

Take a Peec AI project from empty (or broken) to operator-ready: correct competitors, full-funnel prompts, coherent taxonomy, GSC keyword mapping, forum-mined buyer language, and a categorized executable backlog the client can run for the next 2 weeks.

Input

• project_id (resolved via mcp__peec-ai__list_projects)
• target_country — ISO 3166-1 alpha-2 (DE, AT, CH, US, UK, ...). Default DE. Drives SERP/GSC filters and forum source selection.
• prompt_language — ISO 639-1 (de, en, fr, ...). Default = lowercase of target_country (DE → de). Drives the language Peec prompts are authored in.
• Optional: secondary_languages — list, default []. Used for multi-market projects (e.g. DE primary + EN secondary).
• Optional: offer_keywords (retainer, monthly, etc.), own_domain
• Optional: scope — full | audit | partial:<phase> | competitors_only | prompts_only | taxonomy_only (default: auto-detected from setup state, see Phase 0)

Resolving language/country at start:

1. If state file exists with these fields → use them, skip the question.
2. Else if user passed them as arguments → use those.
3. Else infer from own_domain TLD (.de → DE/de, .at → AT/de, .ch → CH/de + ask de/fr, .com → ASK).
4. Else ASK the user once before Phase 1: "Target country (ISO, e.g. DE)? Prompt language (ISO, e.g. de)?". Persist the answer in state.

Never silently default to EN/en when the project has no signal — this corrupts every downstream skill.

Output

A setup report with: before/after counts, funnel distribution (e.g. 5/5/5/5), the single hero prompt to win first, the refresh timeline (24h for fresh data), a categorized P0/P1/P2 backlog, and any user-preference memories saved. No dashboards.

When to use

• "Set up Peec for "
• "My Peec competitors are wrong / not real competitors"
• "Design prompts for my customer journey"
• "Map GSC keywords to my Peec prompts"
• "Restructure Peec topics / tags"
• Audit of an existing AI-visibility tracking setup

Prerequisites

• Peec AI MCP connected (mcp__peec-ai__*)
• Visibly AI MCP connected (mcp__visiblyai__*) — optional, only for GSC
• GSC + GA4 connected inside Visibly AI (check via get_google_connections)

State

This skill owns the setup state file. See _shared/SETUP_STATE.md for the full schema and protocol.

• Reads <project>/growth_loop/setup_state.json at Phase 0 to decide the run mode (full | audit | partial | skip).
• Writes the same file at the end of Phase 9 with merged phases_completed and a fresh snapshot.

All other skills in this repo refuse to run without this file — never bootstrap a setup from inside another skill.

Phase 0 — State check & mode selection

Always runs first. Cheap (single file read + at most one parallel Peec read in brownfield case). Determines whether the rest of the run is needed at all.

1. Read <project>/growth_loop/setup_state.json

2. If state file MISSING:
   2a. Live-detect Peec content (parallel reads):
         list_brands(project)
         list_prompts(project, limit=5)
         list_topics(project)
         list_tags(project)
   2b. If Peec is empty (≤2 brands AND ≤4 prompts AND ≤0 topics):
         → mode = full     (greenfield — proceed to Phase 1)
   2c. If Peec is populated (≥3 brands OR ≥5 prompts OR ≥1 topic):
         → mode = import   (brownfield — see "Import mode" below)

3. If state file PRESENT, branch on `completed_at`:
     < 30 days ago       → mode = skip      (show summary, ASK user before continuing)
     30–90 days ago      → mode = audit     (live-diff snapshot, only redo drifted phases)
     > 90 days ago       → mode = full      (warn: stale)

4. If user passed an explicit `scope`, that wins over auto-detection.

5. Print one line:
     "Setup state: <found|missing|imported> · age: N days · mode: <full|import|audit|partial|skip>"

import mode (brownfield) — runs entirely inside Phase 0

Per _shared/SETUP_STATE.md §import mode, this mode reconstructs setup_state.json from live Peec data without re-doing discovery.

1. Show user one line:
     "Detected existing Peec setup: <N> brands, <M> prompts, <T> topics, <G> tags."
2. ASK three things at once (single user turn):
     - "Import this as the setup state, or run full setup from scratch? [import/full]"
     - "Target country (ISO, e.g. DE)?"
     - "Prompt language (ISO, e.g. de)?"
3. If user picks `import`:
     a. Infer completed_at (NEVER default to now silently):
          read created_at from list_brands + list_prompts;
          completed_at = min(created_at across first 5 brands AND first 5 prompts)
          If unavailable → list_chats(limit=1, sort=asc).timestamp
          If still unavailable → ASK user one bucket question
            ("when did you set this up? [today/past month/past quarter/past year/older]")
            and map to a date.
     b. Build state object:
          phases_completed = inferred from non-empty buckets (brands≥3 → +competitors; etc.)
          snapshot         = the counts just read
          completed_at     = inferred per (a) above
          imported_at      = now (UTC)
          last_audit_at    = now
          hero_prompt_id   = null
          target_country, prompt_language = from user answers in step 2
          notes            = "imported from existing Peec project on <imported_at>;
                              original setup inferred at <completed_at>"
          setup_version    = "1.1"
     c. **Persist immediately** — atomic write to <project>/growth_loop/setup_state.json
        (write to .tmp, then rename). Do not wait for any other phase.
     d. Print:
          "State imported: <project>/growth_loop/setup_state.json (phases: X/7).
           Inferred setup date: <YYYY-MM-DD> (~N days ago).
           Run /peec-agent to pick the next move, or /peec-setup
           partial:gsc_mapping to fill in skipped phases."
     e. Exit Phase 0. Do NOT proceed to Phase 1 — import mode finishes here.
        The user can now invoke any consumer skill; they will all read the freshly
        written state. If they want missing phases (e.g. forum_mining never happened),
        they explicitly call partial:<phase>.
4. If user picks `full`:
     CONFIRM ONCE MORE: "Full setup will create new prompts/topics/tags alongside
     the existing ones. Proceed? [yes/no]"
     On yes → mode = full, proceed to Phase 1.
     On no  → exit cleanly.

skip mode behaviour: show the existing snapshot (counts, phases, hero_prompt_id) and ask "Re-run anyway? [audit / partial: / full / no]". Do not auto-run.

audit mode behaviour: call list_brands / list_prompts / list_topics / list_tags and compare counts to snapshot. For each phase where drift > 20% (or a P0 red flag from Phase 1 reappears), re-run only that phase. Append last_audit_at on write.

partial:<phase> mode: jump straight to the named phase, skip everything else.

If mode == skip and user declines re-run, exit cleanly with a 3-line summary — no further phases.

Phase 0.5 — Business type, audience & page-type taxonomy

Always runs in full, import, and audit modes (only skipped in skip mode). These three fields gate every downstream content decision — a wrong business_type corrupts every brief /peec-content-intel and every zone one-move /peec-cluster emits.

1. Read setup_state.json. If business_type + audience + page_type_taxonomy are all present
   AND setup_version == "1.2" → skip this phase, continue to Phase 1.

2. If any are missing, ASK the user in ONE turn:

   "Before I build prompts, I need three things (all in one message is fine):

    (a) Business type — pick one:
        • b2b-service    (freelancer, agency, consulting — you sell hours or retainers)
        • b2c-ecommerce  (D2C shop — you sell products, typically Shopify/WooCommerce)
        • b2b-saas       (software product with subscriptions)
        • info-product   (courses, memberships, digital products)
        • local-service  (physical location, catchment-area business)
        • marketplace    (multi-seller platform)

    (b) Audience — one sentence on your primary buyer.
        Example: 'Shop-Owner DACH, 3–20 Mitarbeiter, Shopify, 500k–5M Umsatz, Pain: 3 SEO-Agenturen gewechselt.'

    (c) Optional: known buyer pain-points (comma-separated, forum language welcome)."

3. Parse the answer. Build:
     business_type      = one of the six canonical values
     audience.primary   = the sentence
     audience.buyer_personas = extracted nouns from (b) — e.g. ["Shop-Owner Shopify", "DACH"]
     audience.pain_points = list from (c), else []

4. Generate page_type_taxonomy from the business-type matrix
   (see _shared/SETUP_STATE.md §"Business-type → page-type matrix"):

     b2b-service    → ["pillar", "landing_page", "blog_post", "case_study", "comparison", "faq", "pricing"]
     b2c-ecommerce  → ["pdp", "collection", "pillar", "blog_post", "guide", "category_page", "faq"]
     b2b-saas       → ["landing_page", "integration", "use_case", "blog_post", "comparison", "docs", "pricing"]
     info-product   → ["sales_page", "webinar_lp", "blog_post", "case_study", "faq", "lead_magnet"]
     local-service  → ["local_landing", "landing_page", "case_study", "blog_post", "faq"]
     marketplace    → ["collection", "pdp", "category_page", "pillar", "blog_post"]

5. Add "business_type" and "audience" to phases_completed.
   Set setup_version = "1.2".
   Persist immediately (atomic write).

6. Print one line:
     "Business: <business_type> · Audience: <audience.primary> · Page types: <count>"

Why this matters downstream:

• /peec-content-intel picks page_type per brief — if the brief says pdp but business_type=b2b-service, that's a rejected brief (caught by the taxonomy check).
• /peec-cluster names a page_type per zone's one-move. If zone competitors are all CATEGORY_PAGE but your taxonomy can't produce collection, the zone's one-move switches to outreach instead of content creation — automatically.
• /peec-agent reads audience.pain_points when generating Awareness-stage content recommendations.
• /peec-report attributes by page_type to learn which types actually moved visibility.

Never guess business_type. A .de domain selling shoes is not b2b-service even if it looks like a typical German agency URL. Always ASK once; persist once.

Phase 1 — Initial audit

Run in parallel:

mcp__peec-ai__list_projects
mcp__peec-ai__list_brands(project_id)         # current competitors
mcp__peec-ai__list_prompts(project_id, limit=200)
mcp__peec-ai__list_topics(project_id)
mcp__peec-ai__list_tags(project_id)

Red flags to call out:

• Competitors list contains SaaS tool brands (SEMrush, Ahrefs, Sistrix, Moz, Ryte, Yoast, Screaming Frog, SurferSEO, Frase). For a freelancer / consultant project these distort SoV — they are not buyers' alternatives.
• Prompts clustered in one funnel stage only (e.g. all MOFU "empfiehl" — no Awareness / Decision / Retention coverage).
• Topics represent themes only (e.g. "AI" / "SEO") — can't track funnel performance.
• Tags are only Peec's default 4 (branded / non-branded / informational / transactional) — no offer-specific slicing possible.

Phase 2 — Competitor discovery (ground truth)

2a. Extract from AI chats (authoritative)

For each losing prompt (own brand 0% visibility, competitors present):

mcp__peec-ai__list_chats(project_id, start_date, end_date, prompt_id=<losing_prompt>)
  → pick 1 chat per engine (chatgpt-scraper, perplexity-scraper, google-ai-overview-scraper)
mcp__peec-ai__get_chat(project_id, chat_id)
  → inspect messages[] for freelancer / consultant names
  → inspect sources[]  for their domains

Extract: human names, domain names, sources the AI pulled. These are the real competitors LLMs recommend against you.

2b. Supplement with web research

WebSearch("SEO Freelancer Deutschland <niche> 2026")
WebSearch("<niche> Freelancer Experte KI ChatGPT empfehlen")

Cross-check against the domain report — any domain retrieving (get_domain_report) but not tracked as a brand is an invisible competitor:

mcp__peec-ai__get_domain_report(project_id, start_date, end_date, limit=25)
  → find domains with retrieved_percentage > 5% not yet in list_brands

Phase 3 — Competitor curation (mutation)

3a. Add real competitors

Batch-call in parallel:

mcp__peec-ai__create_brand(
  project_id,
  name="<Human name or brand>",
  domains=["their-domain.de"],
  aliases=["Alternate Spelling"]   # Umlaut ↔ ASCII variants, abbreviations
)

Categories to include:

• Direct positioning overlap (e.g. KI-SEO, GEO, Neuro-SEO freelancers)
• Niche-specific freelancers (E-commerce / Shopify SEO)
• Local competitors (same city / region)
• Micro-agencies (5–20 person KI / GEO specialists)
• Invisible competitors already appearing in the domain report

3b. Remove irrelevant competitors

For solo freelancer / service-business projects, remove SaaS tool brands:

mcp__peec-ai__delete_brand(project_id, brand_id)

Tool brands to remove: SEMrush, Ahrefs, Sistrix, Moz, Ryte, Yoast, Screaming Frog, SurferSEO, Frase, SE Ranking.

Deletion is soft. Also save a feedback memory noting "track humans only" so future sessions don't re-suggest these.

Phase 4 — Keyword & intent analysis (Visibly AI + GSC)

4a. Verify GSC connection

mcp__visiblyai__get_google_connections()
  → confirm domain has a gsc_property and (ideally) a GA4 pairing

4b. Pull GSC keywords

mcp__visiblyai__get_keywords(domain="example.com", limit=200, location="Germany")
# or for finer control:
mcp__visiblyai__query_search_console(dimension="query", days=28, country="deu", limit=500)

4c. Classify intent

Cluster keywords into:

• Informational (TOFU) — "was ist", "wie funktioniert", " ohne anmeldung", ratgeber queries
• Brand — client brand name + variations
• Commercial (MOFU) — "beste", "vergleich", "Agentur vs Freelancer"
• Transactional (BOFU) — "Kosten", "Preis", "buchen", "kontaktieren", " + "

Frequent pattern: domain ranks well for TOFU informational (blog traffic) but is invisible for commercial / transactional — those are exactly the queries Peec prompts should test.

4d. Map GSC keywords → Peec prompts

For each top GSC keyword: does a Peec prompt exist that tests AI visibility for the same intent? If not, flag as "prompt gap".

Phase 5 — Forum pain-point mining

Mine verbatim buyer pain from public forums → convert into Peec prompts that match real customer language (not sanitized marketing phrasing). These prompts also reveal what LLMs pull from UGC, and whether the brand surfaces in those answers.

5a. Sources

German (priority for DACH):

• Reddit DE — r/de, r/Finanzen, r/kmu, r/selbststaendig, r/Unternehmer; niche: r/shopify, r/ecommerce, r/SEO
• Gutefrage.net — broadest DE consumer Q&A; strong for commercial / transactional pain
• t3n forum (t3n.de/forum) — DACH digital / business pros
• OMR forum (omr.com/de/forum) — marketing / SEO operator pain
• gründerszene comments / deutsche-startups — B2B startup pain

Global / EN fallback:

• Reddit: r/SEO, r/localseo, r/ecommerce, r/shopify, r/smallbusiness, r/entrepreneur
• Quora
• Stack Exchange (Webmasters, Freelancing) for technical pain

Video / social UGC (via WebFetch):

• YouTube comment sections under competitor videos surfaced in the domain report
• LinkedIn post comments on competitor pulse articles (from get_actions)

5b. Query patterns

Run in parallel — different pain angles:

WebSearch("site:reddit.com <offer-keyword> <problem-word>")
# problem-words: "funktioniert nicht", "erfahrungen", "lohnt sich", "hilfe", "enttäuscht"
WebSearch("site:gutefrage.net <offer-keyword>")
WebSearch("site:t3n.de/forum <niche-keyword>")
WebSearch("site:omr.com <niche-keyword> frage")
WebSearch("<offer-keyword> erfahrungen forum")
WebSearch("<competitor-name> review reddit")

Example for a DACH SEO-retainer project:

• site:reddit.com SEO Freelancer erfahrungen
• site:gutefrage.net SEO Berater lohnt sich
• "Shopify SEO" "funktioniert nicht" forum
• "KI SEO" reddit erfahrung

5c. Extract threads

WebFetch(url, "Extract the original question verbatim, plus the 3 most upvoted answers.
              Note frustrations, decision triggers, and brand / competitor mentions.")

Signals to capture:

• Verbatim question wording — the buyer's natural language
• Frustration markers — "habe schon X ausprobiert", "keine Ergebnisse", "zu teuer", "bin überfordert"
• Decision triggers — "was kostet X?", "wie lange dauert Y?", "reicht selbst machen?", "brauche ich Z?"
• Competitor mentions — names, domains, verdicts
• Thread recency — prioritize last 12 months; older threads ≠ current AI training signal

5d. Convert pain → Peec prompts

Rules:

1. Keep the buyer's language. "Lohnt sich ein SEO-Berater überhaupt?" stays — do not polish to "Welcher Nutzen bietet SEO-Beratung?"
2. Map to funnel stage by intent:
   • "Was ist / wie funktioniert / bin ich zu spät" → Awareness
   • "Freelancer vs Agentur / beste Option / welcher lohnt sich" → Consideration
   • "Was kostet / kann ich buchen / wen kontaktieren" → Decision
   • "Erfahrungen mit X / Fallstudien / funktioniert das wirklich" → Retention
3. Reject pure curiosity. "Was ist KI?" without buying path is out.
4. Business-model fit. Ask: would a buyer asking this become a retainer / one-shot / product buyer? If no, reject.
5. ≤200 chars (Peec limit) — tighten without losing the pain.

5e. Tag for traceability

When creating the prompt in Phase 7, also tag with from-forum (create once: create_tag(name="from-forum", color="slate")). Later you can filter reports to tag_id=from-forum and measure whether pain-point prompts outperform generic ones.

5f. Example transformations

5g. Secondary use

Extracted pain points are also content topics — feed them to the client for blog posts / LinkedIn pulses / YouTube scripts. Answering the pain in owned content is the fastest way to win the corresponding Peec prompt in 6–12 weeks.

Phase 6 — Customer-journey prompt design

4 funnel stages:

Target 5 prompts per stage = 20 total. Below this, per-stage SoV tracking is too noisy.

Prompt quality criteria

A retainer-worthy prompt:

• Asks for exactly what the client sells (offer keywords: "Retainer", "monatlich", "System", "laufend")
• Is MOFU → BOFU intent for Decision prompts (no vague "what is")
• Has competitor weakness built in (tool brands can't answer consultative queries; agencies lose on "persönlich" / "coach"; generalists lose on the client's unique category)
• German for DE market; language-match for other regions
• ≤200 chars

Pick the hero prompt

Identify ONE prompt that:

1. Matches the offer verbatim
2. Is BOFU intent
3. Has competitor weakness (tool brands, agencies, or generalists fail it)
4. Uses the client's differentiator keywords

This is the hero prompt — track weekly.

Phase 7 — Prompt creation

Batch in parallel:

mcp__peec-ai__create_prompt(
  project_id,
  text="...",
  country_code="DE",
  topic_id=<funnel-stage-topic-id>
)

Created prompts have topic_id but no tags — tagging happens in Phase 8.

Credit caution: Each prompt burns daily run credits on Peec TRIAL. For >20, create in waves and review coverage after 48h.

Phase 8 — Taxonomy setup (topics + tags)

8a. Topics = funnel stages

Create 4 topics:

mcp__peec-ai__create_topic(project_id, name="Awareness",     country_code="DE")
mcp__peec-ai__create_topic(project_id, name="Consideration", country_code="DE")
mcp__peec-ai__create_topic(project_id, name="Decision",      country_code="DE")
mcp__peec-ai__create_topic(project_id, name="Retention",     country_code="DE")

If the project had theme-based topics (AI, SEO): rebuild — move each prompt to its funnel topic via update_prompt, then delete_topic the obsolete ones.

8b. Tags = intent + theme

Keep Peec's standard intent tags: branded, non-branded, informational, transactional.

Add theme tags reflecting the offer:

mcp__peec-ai__create_tag(project_id, name="retainer",    color="orange")
mcp__peec-ai__create_tag(project_id, name="e-commerce",  color="purple")
mcp__peec-ai__create_tag(project_id, name="shopify",     color="green")
mcp__peec-ai__create_tag(project_id, name="ai-seo",      color="cyan")
mcp__peec-ai__create_tag(project_id, name="neuro-seo",   color="fuchsia")  # client's proprietary term
mcp__peec-ai__create_tag(project_id, name="coach",       color="teal")
mcp__peec-ai__create_tag(project_id, name="local",       color="yellow")
mcp__peec-ai__create_tag(project_id, name="brand-<name>",color="rose")
mcp__peec-ai__create_tag(project_id, name="from-forum",  color="slate")    # Phase 5 traceability

8c. Assign every prompt

mcp__peec-ai__update_prompt(
  project_id, prompt_id,
  topic_id=<funnel stage>,
  tag_ids=[
    <intent>,         # transactional OR informational
    <branding>,       # branded OR non-branded
    <theme1>, <theme2>, ...
  ]
)

Default mapping:

• Awareness → informational + non-branded
• Consideration → transactional + non-branded (unless explicit brand-Y comparison)
• Decision → transactional + (branded if client brand named, else non-branded)
• Retention → informational / transactional + branded for "Erfahrungen mit "

8d. Clean up

After every prompt has been moved:

mcp__peec-ai__delete_topic(project_id, old_topic_id)

Phase 9 — Reporting & actions

Wait ~24h after setup. Then:

Funnel visibility

mcp__peec-ai__get_brand_report(
  project_id, start_date, end_date,
  dimensions=["topic_id"],
  filters=[{field: "brand_id", operator: "in", values: [own_brand_id]}]
)

Usually exposes the weakest funnel stage — often Awareness if the category is client-invented, or Decision if brand discovery is poor.

Hero prompt tracking

mcp__peec-ai__get_brand_report(
  project_id, start_date, end_date,
  filters=[{field: "prompt_id", operator: "in", values: [<hero_prompt_id>]}],
  dimensions=["model_id"]
)

Theme SoV

mcp__peec-ai__get_brand_report(
  project_id, start_date, end_date,
  filters=[{field: "tag_id", operator: "in", values: [<retainer_tag_id>]}],
  dimensions=["brand_id"]
)

Opportunity actions

mcp__peec-ai__get_actions(project_id, scope="overview",  start_date, end_date)   # top 3 rows
mcp__peec-ai__get_actions(project_id, scope="editorial", url_classification="ARTICLE", ...)
mcp__peec-ai__get_actions(project_id, scope="ugc", domain="youtube.com", ...)
# also try reddit.com, linkedin.com

Deliver as concrete outreach list + content-format guidance from the actions' text column.

Persist setup state (mandatory final step)

Before the deliverable summary, write the state file per _shared/SETUP_STATE.md:

1. Read <project>/growth_loop/setup_state.json (if present).
2. Merge:
     phases_completed    = union(old, phases actually run this session)
     snapshot            = fresh counts from list_brands/list_prompts/list_topics/list_tags
                           called moments ago in this phase
     completed_at        = keep old if present, else now (UTC ISO8601)
     last_audit_at       = now ONLY if this run was mode=audit
     hero_prompt_id      = the one selected in Phase 9
     peec_project_id, domain = from session context
     target_country      = from input (resolved per "Resolving language/country" rules)
     prompt_language     = from input
     secondary_languages = from input (default [])
     setup_version       = "1.1"
3. Write atomically: write to setup_state.json.tmp, then rename.
4. Print exactly one line in the run summary:
     "State written: <project>/growth_loop/setup_state.json (phases: X/7)"

If <project>/growth_loop/ does not exist, create it (this is the same directory the orchestrator and reporter use).

Deliverable structure

At the end of a full setup, present:

1. Before / after table — brand count, prompt count, topics, tags (then vs now)
2. Funnel distribution — e.g. 5/5/5/5
3. Hero prompt callout — which single prompt to win first, and why
4. Refresh timeline — "rerun brand / domain reports in 48h"
5. Categorized backlog (below)
6. Memory hygiene — save preferences uncovered (e.g. "never track tool brands") to feedback memory

Executable backlog template

Every setup ends with a categorized task list the client / user can run in the next 2 weeks. 7 categories. Each task = one line, prefixed with priority (P0 / P1 / P2) and effort (S / M / L).

1. Content — owned domain

• P0 — transactional hero page for the offer (" Retainer") with pricing bands, FAQ schema, CTAs
• P0 — category pillar page for the client's unique term ("Was ist Neuro-SEO?") → targets Awareness
• P1 — case-study page per niche (Shopify / B2B / Local) → targets Retention
• P1 — comparison page ("Freelancer vs Agentur für ") → targets Consideration
• P2 — glossary / FAQ hub covering pain points from Phase 5

2. Editorial outreach

• P0 — pitch inclusion in high-opportunity editorial articles surfaced by get_actions (scope=editorial): evergreen.media, OMR, t3n, niche fachportal
• P1 — 1 guest article per quarter on competitor-cited domains
• P2 — get quoted in roundup / listicle ("Top N in Deutschland")

3. UGC / community

• P0 — presence in Reddit subs from Phase 5 (r/selbststaendig, r/SEO, r/ecommerce, niche-specific) — 1 thread / week with non-spammy branded answers
• P0 — answer top-pain questions on Gutefrage
• P1 — 1 LinkedIn Pulse / month in the format get_actions recommends
• P1 — YouTube content matching the format of the already-cited competitor channel
• P2 — OMR / t3n forum — 1 high-signal reply / month

4. Technical SEO / schema

• P1 — Person + Organization + Service Schema.org on homepage + offer pages
• P1 — FAQPage schema on pillar pages (use mined forum pain as Q&A items)
• P2 — Review / Rating schema if testimonials exist
• P2 — breadcrumbs + internal linking aligned to pillar architecture

5. Peec AI operations (maintenance)

• P0 — weekly review of the hero prompt's visibility curve per engine
• P1 — monthly: new competitors from get_chat → create_brand
• P1 — quarterly: grow from 20 → 50 prompts (add new mined pain points)
• P2 — /schedule trigger for weekly auto-run of brand + domain reports

6. Data ops / analytics

• P1 — connect Visibly AI to the domain's GSC + GA4 if not already (get_google_connections)
• P1 — monthly: are commercial-intent GSC queries rising (CTR + impressions for offer keywords)?
• P2 — cross-reference: does Peec SoV lift correlate with GA4 lead volume lift? Tag leads with "source: AI engine"

7. Positioning / brand

• P0 — ensure homepage + offer pages contain the exact offer language tested in Decision prompts (retainer, monatlich, System, laufend, Neuro-SEO). LLMs can't recommend terminology that isn't on the site.
• P1 — 1 "defining" piece of content per quarter owning the client's category (white paper, podcast series, framework diagram)
• P2 — 1–2 industry events per year; ensure talk abstracts land in event archives (AI-scrapable)

Output format

Present as a sortable table, paste-ready for Notion / Linear:

| # | Priority | Effort | Category | Task | Owner | Due |
|---|----------|--------|----------|------|-------|-----|
| 1 | P0 | M | Content | Build "Neuro-SEO Retainer" landing page with pricing + FAQ schema | Antonio | 2026-05-10 |
| 2 | P0 | S | UGC     | Answer top r/selbststaendig thread on "SEO-Freelancer erfahrungen" | Antonio | 2026-04-26 |
...

Always ≥5 P0 tasks across ≥3 categories. The backlog is only useful if it's executable within 2 weeks.

Customer journey prompt library (reusable starters)

These templates work for most DACH service-business projects. The skeletons stay German because that IS the buyer language being tested — translating to English would break the semantic value. Adapt domain-specific nouns.

Awareness

1. Was ist und wie unterscheidet es sich von ?
2. Wie optimiere ich für ChatGPT- und Perplexity-Empfehlungen?
3. Warum reicht klassisches für 2026 nicht mehr aus?
4. Welche steigern im ?
5. Was bringt langfristige im Vergleich zu einmaligen ?

Consideration

6. Beste in Deutschland für .
7. Freelancer oder Agentur für laufende – was lohnt sich?
8. [hero candidate] Welcher kombiniert mit als monatliches Retainer-Modell?
9. Beste für in der DACH-Region.
10. Welche deutschen bieten monatliche Betreuung inklusive Reporting?

Decision

11. Wer ist und welche bietet <er/sie> an?
12. Was kostet eine monatliche bei einem in Deutschland?
13. Welcher bietet als laufendes System an?
14. für in Deutschland gesucht – wen kontaktieren?
15. Brauche einen persönlichen und keinen Agentur-Vertrieb – wen empfehlt ihr?

Retention

16. Welche in Deutschland haben nachweisbare -Fallstudien?
17. Welche Erfahrungen haben Kunden mit und dem gemacht?
18. Welche deutschen sind für ihre -Publikationen bekannt?
19. Welcher hat messbare Ergebnisse bei -Shops erzielt?
20. Welche veröffentlichen regelmäßig Fallstudien und Ergebnisse?

Quick reference

Guardrails (do not do these)

• Do not track SaaS tool brands as competitors for service-business projects — they aren't buyer alternatives and distort SoV
• Do not create more than 20 prompts at once on TRIAL — credit burn; scale in waves, review after 48h
• Do not exceed 200 chars per prompt — Peec's hard limit
• Do not mix theme + funnel in topics — topics hold one value; use topics for the primary slicing (funnel stage), tags for secondary (theme)
• Do not skip aliases on create_brand — names with Umlauts need ASCII aliases ("Stürkat" + "Stuerkat"), otherwise matching fails
• Do not request reports before 24h of history — prompt runs happen daily; fresh prompts / brands won't appear yet
• Do not delete old topics before moving prompts — prompts become detached; always update_prompt first, then delete_topic
• Do not translate mined buyer language to marketing-speak — "Lohnt sich das?" ≠ "Welcher Nutzen besteht?"; the whole skill depends on verbatim buyer phrasing