Run any Skill in Manus with one click

browse-geo

Stars4

Forks3

UpdatedJuly 13, 2026 at 10:15

Track brand and domain VISIBILITY across AI search engines over a whole query set — Generative Engine Optimization monitoring, not a one-page audit — sweeping each query through Google AI Overviews, Perplexity, and authenticated ChatGPT Search via the `browse` CLI (camoufox for Google), recording each citation into a cross-engine visibility matrix with rates, average position, and competing domains. Reports point-in-time truth: ambiguous citations flagged uncertain, nothing fabricated. Use to monitor a brand's AI-answer presence across engines and queries.

Installation

Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.

Run Skill in Manus

Source

ulpi-io

ulpi-io/skills

View GitHub Repository View Creator Repositories

Download

Run Skill in Manus

Related occupationsSOC

Based on SOC occupation classification

Market Research Analysts and Marketing SpecialistsBusiness and Financial Operations Occupations·SOC 13-1161

SKILL.md

readonly

More from this repository

same repository

laravel

ulpi-io/skills

Write and change Laravel the way THIS project already does it, with Laravel 13 as the recommended baseline for new applications and explicit compatibility handling for existing versions. Carries the real controller/Action/Resource boundaries and conventions for thin controllers, Form Request validation, strict Eloquent, API Resources, Horizon queues, caching, auth, observability, and the Laravel AI/Boost/MCP stack. Use when a task touches this project's Laravel code and should follow its backend conventions rather than generic or outdated framework defaults.

2026-07-234

nextjs

ulpi-io/skills

Build Next.js the way THIS project's App Router already works, with the current stable Next.js 16.2 line recommended for new applications and explicit compatibility handling for existing versions. Carries the real server/client boundaries and conventions for pages, layouts, async request APIs, the project API-client data layer, Server Actions, Cache Components, metadata, i18n, accessibility, analytics, and testing. Use when a task touches this project's Next.js App Router surface and should follow its conventions rather than generic or prerelease defaults.

2026-07-234

ship-playbook

ulpi-io/skills

Take one feature request from prompt to reviewed, audited delivery in a SINGLE autonomous pass — one runnable Workflow that plans, reviews the plan, builds task by task, cross-reviews the build, and optionally runs a launch audit, then RETURNS the verified findings rather than looping (the user decides any fix round; a Workflow can't ask mid-run, and an autonomous fix-loop is what caused multi-hour grinds). It chains the existing skills — plan-to-task-list-with-dag (a specialist agent per task) → plan-founder-review → a specialist engineer/reviewer build across the DAG → a full claude ∥ codex/kiro cross-review → go-live-audit — and FOLLOWS the graph strictly: every task declares its dependencies, layers must be a topological order, plan review blocks a mis-ordered graph, and a task NEVER builds before its dependencies integrate (no building on a broken base). Per-task review is SLICE-SCOPED (judges only that task's own change against its acceptance criteria, attributing whole-codebase end-state gaps to the ta

2026-07-134

ast-grep

ulpi-io/skills

Search code by SYNTAX SHAPE, not by text — matching structures grep and regex can't reliably express — with the `ast-grep` CLI: parse to an AST and match with patterns, node kinds, relational rules (`inside`/`has`), and metavariables, inspecting the tree via `--debug-query` and proving the rule on a minimal example before it runs repo-wide. Requires the `ast-grep` CLI; results are spot-checked, not returned as unverified noise. Use when the target is a code structure rather than a literal string.

2026-07-134

branch-review-before-pr

ulpi-io/skills

Gate a branch before it becomes a PR — catch the STRUCTURAL defects tests miss, not style: read the full diff against the default base, run a two-pass checklist (blocking pass first — unsafe queries, race conditions, trust-boundary and auth mistakes, conditional side effects — then the non-blocking remainder), and verify each candidate against surrounding code before reporting. Stays read-only and reports blocking-first; only becomes mutating after you explicitly approve a specific fix per issue — never batches decisions or auto-fixes. Use as the branch gate right before shipping or opening a PR.

2026-07-134

browse-aeo

ulpi-io/skills

Score a page for how well AI answer engines can CITE it — Answer Engine Optimization, not classic rankings — by pulling structured data, meta, headings, and answer-shaped content via the `browse` CLI (schema/meta/headings/text) into a weighted 0-100 audit, plus a SERP mode that reads Google AI Overviews, Perplexity, and ChatGPT Search snapshots to see who actually gets cited. Never fabricates a score: an un-evaluable dimension is marked N/A, and "appears in AI Overviews" is asserted only after a real SERP check. Use to make a page answer-ready or to check its AI-answer visibility.

2026-07-134

name	browse-geo
version	1.0.0
description	Track brand and domain VISIBILITY across AI search engines over a whole query set — Generative Engine Optimization monitoring, not a one-page audit — sweeping each query through Google AI Overviews, Perplexity, and authenticated ChatGPT Search via the `browse` CLI (camoufox for Google), recording each citation into a cross-engine visibility matrix with rates, average position, and competing domains. Reports point-in-time truth: ambiguous citations flagged uncertain, nothing fabricated. Use to monitor a brand's AI-answer presence across engines and queries.
allowed-tools	["Bash","Read","AskUserQuestion"]
argument-hint	[brand queries or domain to monitor]
arguments	["request"]
when_to_use	Use when the user wants GEO monitoring, AI-visibility tracking, or brand monitoring across AI search — "does my domain appear in AI Overviews for these queries", "monitor brand visibility across Perplexity and ChatGPT". Do NOT use for traditional SEO — rankings, meta, crawlability (browse-seo) — or a one-page answerability audit (browse-aeo); this is a repeatable multi-query, multi-engine presence sweep, not a single-page check.
effort	high

browse-geo: Generative Engine Optimization Monitoring

Goal

Monitor how a brand or domain appears in AI-generated search results across three engines: Google AI Overviews, Perplexity, and ChatGPT Search. Produce a visibility matrix showing which queries surface the target domain, in what position, and with what context.

Prerequisites

Camoufox is required for Google (bot detection). Check availability:

browse --runtime camoufox doctor

If camoufox is not installed, stop and tell the user to install it manually:

Install it with: npm install camoufox-js && npx camoufox-js fetch

Do NOT install anything automatically.

For ChatGPT Search, a persistent browser profile with an authenticated ChatGPT session is required. If one does not exist, ask the user to authenticate:

browse --profile chatgpt --headed goto https://chatgpt.com
# User logs in manually via headed browser
# Profile persists cookies for future sessions

Step 0: Gather inputs

Before running any queries, collect from the user:

Target domain — the domain to track (e.g., example.com)
Query list — 3-10 brand-relevant search queries
Engines — which engines to check (default: all three)

If the user provides only a domain, suggest relevant queries based on the domain's likely industry and product category. Use AskUserQuestion to confirm the query list.

Step 1: Google AI Overviews

Google AI Overviews appear at the top of search results for informational queries. Use camoufox with consent dismissal to avoid bot detection and cookie banners.

Navigate and extract

For each query:

BROWSE_CONSENT_DISMISS=1 browse --runtime camoufox --headed goto "https://www.google.com/search?q=<url-encoded-query>"
browse --runtime camoufox --headed wait --network-idle
browse --runtime camoufox --headed snapshot -i

Analyze results

Read the snapshot output. The AI Overview section typically has an "AI Overview" label, expandable summary text with inline citations, and source links. If present, use browse --runtime camoufox --headed text to extract full content.

For each query, record: ai_overview_present (yes/no), domain_cited (yes/no), citation_position (number or null), citation_context (the claim it supports), and competing_domains (other cited domains).

Step 2: Perplexity

Perplexity shows AI-generated answers with numbered source citations.

Navigate and extract

For each query:

browse goto "https://www.perplexity.ai/search?q=<url-encoded-query>"
browse wait --network-idle
browse snapshot -i

Analyze results

Perplexity shows numbered footnote-style citations (e.g., [1], [2]) within the answer and a "Sources" section with URLs. Use browse text for full content if needed.

For each query, record: answer_generated (yes/no), domain_cited (yes/no), citation_numbers (positions referencing the target domain), citation_context, total_citations, and competing_domains.

Step 3: ChatGPT Search (authenticated)

ChatGPT Search requires an authenticated session. Use a persistent profile.

Navigate and query

For each query:

browse --profile chatgpt goto https://chatgpt.com
browse --profile chatgpt snapshot -i

Find the input field from the snapshot, then:

browse --profile chatgpt fill <input-ref> "<query>"
browse --profile chatgpt press Enter
browse --profile chatgpt wait --network-idle

ChatGPT streams responses. Wait for output to stabilize, then snapshot:

browse --profile chatgpt wait --network-idle
browse --profile chatgpt snapshot -i

If a stop/regenerate button is visible, the response is still streaming — wait and re-snapshot. Use browse --profile chatgpt text for full content extraction.

Analyze results

ChatGPT Search shows inline numbered citation links and a "Sources" panel with URLs.

For each query, record: response_generated (yes/no), search_used (yes/no -- ChatGPT may answer from training data without search), domain_cited (yes/no), citation_position (number or null), citation_context, and competing_domains.

Step 4: Generate visibility report

After running all queries across selected engines, compile the results into a structured report.

Visibility matrix

Create a table with queries as rows and engines as columns:

| Query                  | Google AI Overview | Perplexity | ChatGPT Search |
|------------------------|--------------------|------------|----------------|
| "best <product>"       | Cited (#2)         | Cited (#1) | Not cited      |
| "<brand> vs competitor"| No AI Overview     | Cited (#3) | Cited (#2)     |
| "how to <task>"        | Cited (#1)         | Not cited  | Not cited      |

Summary metrics

Calculate and report:

Visibility rate: percentage of queries where the domain appears, per engine
Average citation position: mean position when cited, per engine
Best-performing queries: queries where the domain appears across multiple engines
Gap queries: queries where the domain is absent from all engines
Top competing domains: domains that appear most frequently across all queries

Recommendations

Based on the findings, suggest:

Which queries have the highest AI visibility potential
Where competitors are cited but the target domain is not
Content gaps that could improve citation likelihood
Which engines favor the domain (focus optimization there)

Multi-query workflow

When running many queries, batch by engine to minimize context switching:

Run all queries on Google AI Overviews first (camoufox session stays warm)
Run all queries on Perplexity second (no special runtime needed)
Run all queries on ChatGPT Search last (authenticated profile session)

Between queries on the same engine, no need to restart the browser. Navigate directly to the next search URL.

Important rules

Camoufox for Google — Google blocks regular Chromium for automated searches. Always use --runtime camoufox --headed for Google queries.
Rate limiting — Add natural pauses between queries on the same engine. Do not run more than one query every 5-10 seconds on Google. Perplexity and ChatGPT are more lenient.
AI Overviews are not always present — Google shows AI Overviews for informational queries, not navigational or transactional ones. Record absence as a data point.
ChatGPT may not use search — ChatGPT sometimes answers from training data without invoking web search. When no sources panel appears, record search_used: no.
Snapshot before text — always take a snapshot first to understand page structure, then use text extraction for full content if needed.
Do not fabricate results — if a citation is ambiguous or unclear, note it as uncertain rather than asserting presence or absence.
Profile persistence — the --profile chatgpt flag reuses cookies across sessions. If the session expires, ask the user to re-authenticate via headed mode.

Limitations

Google AI Overviews availability — not all queries trigger AI Overviews; availability varies by region and query type
ChatGPT Search access — requires a ChatGPT Plus or Team subscription with search enabled
Rate limits — aggressive querying may trigger temporary blocks on any engine
Dynamic content — AI-generated answers change over time; results represent a point-in-time snapshot
Image/video citations — this workflow tracks text citations only; rich media citations in AI answers are not captured